include/gen/fasttest_gen.inl.h

//
// include/gen/fasttest_gen.inl.h
// Generated by AMC
//
// Copyright (C) 2008-2013 AlgoEngineering LLC
// Copyright (C) 2013-2019 NYSE | Intercontinental Exchange
// Copyright (C) 2020-2023 Astra
// Copyright (C) 2023 AlgoRND
//
// This source code constitutes confidential information and trade secrets
// of AlgoRND. Unauthorized copying, distribution or sharing of this file,
// via any medium, is strictly prohibited.
//


#pragma once
#include "include/gen/algo_gen.inl.h"
//#pragma endinclude
inline fasttest::BVConst::BVConst() {
    fasttest::BVConst_Init(*this);
}


// --- fasttest.BVConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVConst.
// If not successful, quietly return NULL.
inline fasttest::BVConst* fasttest::BVConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (23);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVConst);
    return cond ? reinterpret_cast<fasttest::BVConst*>(&hdr) : NULL;
}

// --- fasttest.BVConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVConst.Value.Get
inline algo::strptr fasttest::Value_Get(fasttest::BVConst& parent) {
    (void)parent;
    return algo::strptr("B23");
}

// --- fasttest.BVConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVConst& parent) {
    return i32(const_cast<fasttest::BVConst&>(parent).length);
}

// --- fasttest.BVConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVConst&>(row).length));
}

// --- fasttest.BVConst..Init
// Set all fields to initial values.
inline void fasttest::BVConst_Init(fasttest::BVConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(23);
}
inline fasttest::BVConstOpt::BVConstOpt() {
    fasttest::BVConstOpt_Init(*this);
}


// --- fasttest.BVConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVConstOpt.
// If not successful, quietly return NULL.
inline fasttest::BVConstOpt* fasttest::BVConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (24);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVConstOpt);
    return cond ? reinterpret_cast<fasttest::BVConstOpt*>(&hdr) : NULL;
}

// --- fasttest.BVConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVConstOpt& parent, fasttest::BVConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVConstOpt& parent, fasttest::BVConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVConstOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::BVConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVConstOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::BVConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVConstOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::BVConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVConstOpt.Value.Get
inline algo::strptr fasttest::Value_Get(fasttest::BVConstOpt& parent) {
    (void)parent;
    return algo::strptr("B24");
}

// --- fasttest.BVConstOpt.pmask_bitcurs.Reset
inline void fasttest::BVConstOpt_pmask_bitcurs_Reset(BVConstOpt_pmask_bitcurs &curs, fasttest::BVConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVConstOpt_pmask_bitcurs_ValidQ(BVConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::BVConstOpt_pmask_bitcurs_Access(BVConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVConstOpt& parent) {
    return i32(const_cast<fasttest::BVConstOpt&>(parent).length);
}

// --- fasttest.BVConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVConstOpt&>(row).length));
}

// --- fasttest.BVConstOpt..Init
// Set all fields to initial values.
inline void fasttest::BVConstOpt_Init(fasttest::BVConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(24);
    parent.pmask = u32(0);
}
inline fasttest::BVCopy::BVCopy() {
    fasttest::BVCopy_Init(*this);
}


// --- fasttest.BVCopy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVCopy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVCopy.
// If not successful, quietly return NULL.
inline fasttest::BVCopy* fasttest::BVCopy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (58);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVCopy);
    return cond ? reinterpret_cast<fasttest::BVCopy*>(&hdr) : NULL;
}

// --- fasttest.BVCopy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVCopy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVCopy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVCopy& parent) {
    return i32(const_cast<fasttest::BVCopy&>(parent).length);
}

// --- fasttest.BVCopy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVCopy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVCopy&>(row).length));
}

// --- fasttest.BVCopy..Init
// Set all fields to initial values.
inline void fasttest::BVCopy_Init(fasttest::BVCopy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(58);
    parent.Value58 = algo::strptr("B58");
}
inline fasttest::BVCopyNull::BVCopyNull() {
    fasttest::BVCopyNull_Init(*this);
}


// --- fasttest.BVCopyNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVCopyNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVCopyNull.
// If not successful, quietly return NULL.
inline fasttest::BVCopyNull* fasttest::BVCopyNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (60);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVCopyNull);
    return cond ? reinterpret_cast<fasttest::BVCopyNull*>(&hdr) : NULL;
}

// --- fasttest.BVCopyNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVCopyNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVCopyNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVCopyNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVCopyNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVCopyNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVCopyNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVCopyNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVCopyNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVCopyNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVCopyNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVCopyNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVCopyNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVCopyNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVCopyNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVCopyNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVCopyNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVCopyNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVCopyNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVCopyNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVCopyNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVCopyNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVCopyNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVCopyNull& parent, fasttest::BVCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVCopyNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVCopyNull& parent, fasttest::BVCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVCopyNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVCopyNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVCopyNull.Value60.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value60_PresentQ(fasttest::BVCopyNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVCopyNull.Value60.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value60_SetPresent(fasttest::BVCopyNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVCopyNull.Value60.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value60_Present_GetBit(fasttest::BVCopyNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVCopyNull.Value60.Set
inline void fasttest::Value60_Set(fasttest::BVCopyNull& parent, const algo::strptr& rhs) {
    parent.Value60 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVCopyNull.pmask_bitcurs.Reset
inline void fasttest::BVCopyNull_pmask_bitcurs_Reset(BVCopyNull_pmask_bitcurs &curs, fasttest::BVCopyNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVCopyNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVCopyNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVCopyNull_pmask_bitcurs_ValidQ(BVCopyNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVCopyNull.pmask_bitcurs.Access
// item access
inline int& fasttest::BVCopyNull_pmask_bitcurs_Access(BVCopyNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVCopyNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVCopyNull& parent) {
    return i32(const_cast<fasttest::BVCopyNull&>(parent).length);
}

// --- fasttest.BVCopyNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVCopyNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVCopyNull&>(row).length));
}

// --- fasttest.BVCopyNull..Init
// Set all fields to initial values.
inline void fasttest::BVCopyNull_Init(fasttest::BVCopyNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(60);
    parent.pmask = u32(0);
}
inline fasttest::BVCopyOpt::BVCopyOpt() {
    fasttest::BVCopyOpt_Init(*this);
}


// --- fasttest.BVCopyOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVCopyOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVCopyOpt.
// If not successful, quietly return NULL.
inline fasttest::BVCopyOpt* fasttest::BVCopyOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (59);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVCopyOpt);
    return cond ? reinterpret_cast<fasttest::BVCopyOpt*>(&hdr) : NULL;
}

// --- fasttest.BVCopyOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVCopyOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVCopyOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVCopyOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVCopyOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVCopyOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVCopyOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVCopyOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVCopyOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVCopyOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVCopyOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVCopyOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVCopyOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVCopyOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVCopyOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVCopyOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVCopyOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVCopyOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVCopyOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVCopyOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVCopyOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVCopyOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVCopyOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVCopyOpt& parent, fasttest::BVCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVCopyOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVCopyOpt& parent, fasttest::BVCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVCopyOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVCopyOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVCopyOpt.Value59.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value59_PresentQ(fasttest::BVCopyOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVCopyOpt.Value59.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value59_SetPresent(fasttest::BVCopyOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVCopyOpt.Value59.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value59_Present_GetBit(fasttest::BVCopyOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVCopyOpt.Value59.Set
inline void fasttest::Value59_Set(fasttest::BVCopyOpt& parent, const algo::strptr& rhs) {
    parent.Value59 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVCopyOpt.pmask_bitcurs.Reset
inline void fasttest::BVCopyOpt_pmask_bitcurs_Reset(BVCopyOpt_pmask_bitcurs &curs, fasttest::BVCopyOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVCopyOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVCopyOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVCopyOpt_pmask_bitcurs_ValidQ(BVCopyOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVCopyOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::BVCopyOpt_pmask_bitcurs_Access(BVCopyOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVCopyOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVCopyOpt& parent) {
    return i32(const_cast<fasttest::BVCopyOpt&>(parent).length);
}

// --- fasttest.BVCopyOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVCopyOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVCopyOpt&>(row).length));
}

// --- fasttest.BVCopyOpt..Init
// Set all fields to initial values.
inline void fasttest::BVCopyOpt_Init(fasttest::BVCopyOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(59);
    parent.pmask = u32(0);
    parent.Value59 = algo::strptr("B59");
}
inline fasttest::BVDflt::BVDflt() {
    fasttest::BVDflt_Init(*this);
}


// --- fasttest.BVDflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVDflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVDflt.
// If not successful, quietly return NULL.
inline fasttest::BVDflt* fasttest::BVDflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (42);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVDflt);
    return cond ? reinterpret_cast<fasttest::BVDflt*>(&hdr) : NULL;
}

// --- fasttest.BVDflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVDflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVDflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVDflt& parent) {
    return i32(const_cast<fasttest::BVDflt&>(parent).length);
}

// --- fasttest.BVDflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVDflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVDflt&>(row).length));
}

// --- fasttest.BVDflt..Init
// Set all fields to initial values.
inline void fasttest::BVDflt_Init(fasttest::BVDflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(42);
    parent.Value = algo::strptr("B42");
}
inline fasttest::BVDfltNull::BVDfltNull() {
    fasttest::BVDfltNull_Init(*this);
}


// --- fasttest.BVDfltNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVDfltNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVDfltNull.
// If not successful, quietly return NULL.
inline fasttest::BVDfltNull* fasttest::BVDfltNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (44);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVDfltNull);
    return cond ? reinterpret_cast<fasttest::BVDfltNull*>(&hdr) : NULL;
}

// --- fasttest.BVDfltNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVDfltNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVDfltNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVDfltNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVDfltNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVDfltNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVDfltNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVDfltNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVDfltNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVDfltNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVDfltNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVDfltNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVDfltNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVDfltNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVDfltNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVDfltNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVDfltNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVDfltNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVDfltNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVDfltNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVDfltNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVDfltNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVDfltNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVDfltNull& parent, fasttest::BVDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVDfltNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVDfltNull& parent, fasttest::BVDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVDfltNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVDfltNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVDfltNull.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::BVDfltNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVDfltNull.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::BVDfltNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVDfltNull.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::BVDfltNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVDfltNull.Value.Set
inline void fasttest::Value_Set(fasttest::BVDfltNull& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVDfltNull.pmask_bitcurs.Reset
inline void fasttest::BVDfltNull_pmask_bitcurs_Reset(BVDfltNull_pmask_bitcurs &curs, fasttest::BVDfltNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVDfltNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVDfltNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVDfltNull_pmask_bitcurs_ValidQ(BVDfltNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVDfltNull.pmask_bitcurs.Access
// item access
inline int& fasttest::BVDfltNull_pmask_bitcurs_Access(BVDfltNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVDfltNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVDfltNull& parent) {
    return i32(const_cast<fasttest::BVDfltNull&>(parent).length);
}

// --- fasttest.BVDfltNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVDfltNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVDfltNull&>(row).length));
}

// --- fasttest.BVDfltNull..Init
// Set all fields to initial values.
inline void fasttest::BVDfltNull_Init(fasttest::BVDfltNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(44);
    parent.pmask = u32(0);
}
inline fasttest::BVDfltOpt::BVDfltOpt() {
    fasttest::BVDfltOpt_Init(*this);
}


// --- fasttest.BVDfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVDfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVDfltOpt.
// If not successful, quietly return NULL.
inline fasttest::BVDfltOpt* fasttest::BVDfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (43);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVDfltOpt);
    return cond ? reinterpret_cast<fasttest::BVDfltOpt*>(&hdr) : NULL;
}

// --- fasttest.BVDfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVDfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVDfltOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVDfltOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVDfltOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVDfltOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVDfltOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVDfltOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVDfltOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVDfltOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVDfltOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVDfltOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVDfltOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVDfltOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVDfltOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVDfltOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVDfltOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVDfltOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVDfltOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVDfltOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVDfltOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVDfltOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVDfltOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVDfltOpt& parent, fasttest::BVDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVDfltOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVDfltOpt& parent, fasttest::BVDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVDfltOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVDfltOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVDfltOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::BVDfltOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVDfltOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::BVDfltOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVDfltOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::BVDfltOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVDfltOpt.Value.Set
inline void fasttest::Value_Set(fasttest::BVDfltOpt& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVDfltOpt.pmask_bitcurs.Reset
inline void fasttest::BVDfltOpt_pmask_bitcurs_Reset(BVDfltOpt_pmask_bitcurs &curs, fasttest::BVDfltOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVDfltOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVDfltOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVDfltOpt_pmask_bitcurs_ValidQ(BVDfltOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVDfltOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::BVDfltOpt_pmask_bitcurs_Access(BVDfltOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVDfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVDfltOpt& parent) {
    return i32(const_cast<fasttest::BVDfltOpt&>(parent).length);
}

// --- fasttest.BVDfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVDfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVDfltOpt&>(row).length));
}

// --- fasttest.BVDfltOpt..Init
// Set all fields to initial values.
inline void fasttest::BVDfltOpt_Init(fasttest::BVDfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(43);
    parent.pmask = u32(0);
    parent.Value = algo::strptr("B43");
}
inline fasttest::BVNone::BVNone() {
    fasttest::BVNone_Init(*this);
}


// --- fasttest.BVNone.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVNone by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVNone.
// If not successful, quietly return NULL.
inline fasttest::BVNone* fasttest::BVNone_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (7);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVNone);
    return cond ? reinterpret_cast<fasttest::BVNone*>(&hdr) : NULL;
}

// --- fasttest.BVNone.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVNone& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVNone..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVNone& parent) {
    return i32(const_cast<fasttest::BVNone&>(parent).length);
}

// --- fasttest.BVNone..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVNone& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVNone&>(row).length));
}

// --- fasttest.BVNone..Init
// Set all fields to initial values.
inline void fasttest::BVNone_Init(fasttest::BVNone& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(7);
}
inline fasttest::BVNoneOpt::BVNoneOpt() {
    fasttest::BVNoneOpt_Init(*this);
}


// --- fasttest.BVNoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of BVNoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of BVNoneOpt.
// If not successful, quietly return NULL.
inline fasttest::BVNoneOpt* fasttest::BVNoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (8);
    cond &= i32(hdr.length) >= ssizeof(fasttest::BVNoneOpt);
    return cond ? reinterpret_cast<fasttest::BVNoneOpt*>(&hdr) : NULL;
}

// --- fasttest.BVNoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::BVNoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.BVNoneOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::BVNoneOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.BVNoneOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::BVNoneOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.BVNoneOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::BVNoneOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.BVNoneOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.BVNoneOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.BVNoneOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::BVNoneOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.BVNoneOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::BVNoneOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.BVNoneOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.BVNoneOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.BVNoneOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.BVNoneOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::BVNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.BVNoneOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::BVNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.BVNoneOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::BVNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.BVNoneOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::BVNoneOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.BVNoneOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::BVNoneOpt& parent, fasttest::BVNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVNoneOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::BVNoneOpt& parent, fasttest::BVNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.BVNoneOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::BVNoneOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.BVNoneOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::BVNoneOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.BVNoneOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::BVNoneOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVNoneOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::BVNoneOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.BVNoneOpt.Value.Set
inline void fasttest::Value_Set(fasttest::BVNoneOpt& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.BVNoneOpt.pmask_bitcurs.Reset
inline void fasttest::BVNoneOpt_pmask_bitcurs_Reset(BVNoneOpt_pmask_bitcurs &curs, fasttest::BVNoneOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    BVNoneOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.BVNoneOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::BVNoneOpt_pmask_bitcurs_ValidQ(BVNoneOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.BVNoneOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::BVNoneOpt_pmask_bitcurs_Access(BVNoneOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.BVNoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::BVNoneOpt& parent) {
    return i32(const_cast<fasttest::BVNoneOpt&>(parent).length);
}

// --- fasttest.BVNoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::BVNoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::BVNoneOpt&>(row).length));
}

// --- fasttest.BVNoneOpt..Init
// Set all fields to initial values.
inline void fasttest::BVNoneOpt_Init(fasttest::BVNoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(8);
    parent.pmask = u32(0);
}
inline fasttest::SampleEnum::SampleEnum(u32                            in_value)
    : value(in_value)
{
}
inline fasttest::SampleEnum::SampleEnum(fasttest_SampleEnumEnum arg) { this->value = u32(arg); }
inline fasttest::SampleEnum::SampleEnum() {
    fasttest::SampleEnum_Init(*this);
}


// --- fasttest.SampleEnum.value.GetEnum
// Get value of field as enum type
inline fasttest_SampleEnumEnum fasttest::value_GetEnum(const fasttest::SampleEnum& parent) {
    return fasttest_SampleEnumEnum(parent.value);
}

// --- fasttest.SampleEnum.value.SetEnum
// Set value of field from enum type.
inline void fasttest::value_SetEnum(fasttest::SampleEnum& parent, fasttest_SampleEnumEnum rhs) {
    parent.value = u32(rhs);
}

// --- fasttest.SampleEnum.value.Cast
inline fasttest::SampleEnum::operator fasttest_SampleEnumEnum () const {
    return fasttest_SampleEnumEnum((*this).value);
}

// --- fasttest.SampleEnum..Init
// Set all fields to initial values.
inline void fasttest::SampleEnum_Init(fasttest::SampleEnum& parent) {
    parent.value = u32(0);
}
inline fasttest::SampleSet::SampleSet(u32                            in_value)
    : value(in_value)
{
}
inline fasttest::SampleSet::SampleSet(fasttest_SampleSet_value_Enum arg) { this->value = u32(arg); }
inline fasttest::SampleSet::SampleSet() {
    fasttest::SampleSet_Init(*this);
}


// --- fasttest.SampleSet.prima.Get
// Retrieve bitfield from value of field value
//    1 bits starting at bit 0.
inline bool fasttest::prima_Get(const fasttest::SampleSet& parent) {
    return bool((parent.value >> 0) & 0x01);
}

// --- fasttest.SampleSet.prima.Set
// Set bitfield in value of field 'value'
//    1 bits starting at bit 0.
inline void fasttest::prima_Set(fasttest::SampleSet& parent, bool rhs) {
    u32 t1    = u32(0x01) << 0;
    u32 t2    = (u32(rhs) & 0x01) << 0;
    parent.value = u32((parent.value & ~t1) | t2);
}

// --- fasttest.SampleSet.secunda.Get
// Retrieve bitfield from value of field value
//    1 bits starting at bit 1.
inline bool fasttest::secunda_Get(const fasttest::SampleSet& parent) {
    return bool((parent.value >> 1) & 0x01);
}

// --- fasttest.SampleSet.secunda.Set
// Set bitfield in value of field 'value'
//    1 bits starting at bit 1.
inline void fasttest::secunda_Set(fasttest::SampleSet& parent, bool rhs) {
    u32 t1    = u32(0x01) << 1;
    u32 t2    = (u32(rhs) & 0x01) << 1;
    parent.value = u32((parent.value & ~t1) | t2);
}

// --- fasttest.SampleSet.tertia.Get
// Retrieve bitfield from value of field value
//    1 bits starting at bit 2.
inline bool fasttest::tertia_Get(const fasttest::SampleSet& parent) {
    return bool((parent.value >> 2) & 0x01);
}

// --- fasttest.SampleSet.tertia.Set
// Set bitfield in value of field 'value'
//    1 bits starting at bit 2.
inline void fasttest::tertia_Set(fasttest::SampleSet& parent, bool rhs) {
    u32 t1    = u32(0x01) << 2;
    u32 t2    = (u32(rhs) & 0x01) << 2;
    parent.value = u32((parent.value & ~t1) | t2);
}

// --- fasttest.SampleSet..Init
// Set all fields to initial values.
inline void fasttest::SampleSet_Init(fasttest::SampleSet& parent) {
    parent.value = u32(0);
}
inline fasttest::FastState::FastState() {
    fasttest::FastState_Init(*this);
}


// --- fasttest.FastState.assigned.N
// Return constant 1
inline int fasttest::assigned_N(fasttest::FastState& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.FastState.assigned.qFind
// Access value
inline u64& fasttest::assigned_qFind(fasttest::FastState& parent, int) {
    return parent.assigned;
}

// --- fasttest.FastState.assigned.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::assigned_Nbits(fasttest::FastState& parent) {
    return assigned_N(parent) * 64;
}

// --- fasttest.FastState.assigned.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::assigned_qGetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = assigned_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.FastState.assigned.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::assigned_GetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    bool ret = false;
    u64 lim = assigned_N(parent);
    if (elem_idx < lim) {
        u64 &elem = assigned_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.FastState.assigned.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::assigned_BitsEmptyQ(fasttest::FastState& parent) {
    bool retval = true;
    u64 n = assigned_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (assigned_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.FastState.assigned.Sum1s
inline u64 fasttest::assigned_Sum1s(fasttest::FastState& parent) {
    u64 sum = 0;
    u64 n = assigned_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u64_Count1s(assigned_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.FastState.assigned.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::assigned_qClearBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = assigned_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u64(1) << shift); // clear bit
}

// --- fasttest.FastState.assigned.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::assigned_ClearBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 lim = assigned_N(parent);
    if (elem_idx < lim) {
        u64 &elem = assigned_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u64(1) << shift); // clear bit
    }
}

// --- fasttest.FastState.assigned.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::assigned_qSetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = assigned_qFind(parent, elem_idx); // fetch
    elem = elem | (u64(1) << shift); // set bit
}

// --- fasttest.FastState.assigned.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::assigned_SetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 lim = assigned_N(parent);
    if (elem_idx < lim) {
        u64 &elem = assigned_qFind(parent, elem_idx); // fetch
        elem = elem | (u64(1) << shift); // set bit
    }
}

// --- fasttest.FastState.assigned.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::assigned_qSetBitVal(fasttest::FastState& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = assigned_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u64(1) << shift)) | (u64(val) << shift); // insert new value
}

// --- fasttest.FastState.assigned.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::assigned_qOrBitVal(fasttest::FastState& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = assigned_qFind(parent, elem_idx); // fetch
    elem = elem | (u64(val) << shift); // Or in val into elem
}

// --- fasttest.FastState.assigned.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::assigned_ClearBitsAll(fasttest::FastState& parent) {
    u64 n = assigned_N(parent);
    for (u64 i = 0; i < n; i++) {
        assigned_qFind(parent, i) = 0;
    }
}

// --- fasttest.FastState.assigned.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::assigned_ClearBits(fasttest::FastState& parent, fasttest::FastState &rhs) {
    u64 n = u64_Min(assigned_N(parent), assigned_N(rhs));
    for (u64 i = 0; i < n; i++) {
        assigned_qFind(parent, i) &= ~assigned_qFind(rhs, i);
    }
}

// --- fasttest.FastState.assigned.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::assigned_OrBits(fasttest::FastState& parent, fasttest::FastState &rhs) {
    u64 n = u64_Min(assigned_N(parent), assigned_N(rhs));
    for (u64 i = 0; i < n; i++) {
        assigned_qFind(parent, i) |= assigned_qFind(rhs, i);
    }
}

// --- fasttest.FastState.assigned.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::assigned_Sup(fasttest::FastState& parent) {
    u64 lim = assigned_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u64 &val = assigned_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 64 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.FastState.present.N
// Return constant 1
inline int fasttest::present_N(fasttest::FastState& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.FastState.present.qFind
// Access value
inline u32& fasttest::present_qFind(fasttest::FastState& parent, int) {
    return parent.present;
}

// --- fasttest.FastState.present.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::present_Nbits(fasttest::FastState& parent) {
    return present_N(parent) * 32;
}

// --- fasttest.FastState.present.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::present_qGetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = present_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.FastState.present.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::present_GetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = present_N(parent);
    if (elem_idx < lim) {
        u32 &elem = present_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.FastState.present.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::present_BitsEmptyQ(fasttest::FastState& parent) {
    bool retval = true;
    u64 n = present_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (present_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.FastState.present.Sum1s
inline u64 fasttest::present_Sum1s(fasttest::FastState& parent) {
    u64 sum = 0;
    u64 n = present_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(present_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.FastState.present.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::present_qClearBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = present_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.FastState.present.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::present_ClearBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = present_N(parent);
    if (elem_idx < lim) {
        u32 &elem = present_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.FastState.present.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::present_qSetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = present_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.FastState.present.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::present_SetBit(fasttest::FastState& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = present_N(parent);
    if (elem_idx < lim) {
        u32 &elem = present_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.FastState.present.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::present_qSetBitVal(fasttest::FastState& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = present_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.FastState.present.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::present_qOrBitVal(fasttest::FastState& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = present_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.FastState.present.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::present_ClearBitsAll(fasttest::FastState& parent) {
    u64 n = present_N(parent);
    for (u64 i = 0; i < n; i++) {
        present_qFind(parent, i) = 0;
    }
}

// --- fasttest.FastState.present.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::present_ClearBits(fasttest::FastState& parent, fasttest::FastState &rhs) {
    u64 n = u64_Min(present_N(parent), present_N(rhs));
    for (u64 i = 0; i < n; i++) {
        present_qFind(parent, i) &= ~present_qFind(rhs, i);
    }
}

// --- fasttest.FastState.present.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::present_OrBits(fasttest::FastState& parent, fasttest::FastState &rhs) {
    u64 n = u64_Min(present_N(parent), present_N(rhs));
    for (u64 i = 0; i < n; i++) {
        present_qFind(parent, i) |= present_qFind(rhs, i);
    }
}

// --- fasttest.FastState.present.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::present_Sup(fasttest::FastState& parent) {
    u64 lim = present_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = present_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.FastState.tid.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::tid_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 37);
}

// --- fasttest.FastState.tid.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::tid_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 37); // mark presence in pmask
}

// --- fasttest.FastState.tid.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::tid_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 37;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.tid.Set
inline void fasttest::tid_Set(fasttest::FastState& parent, u32 rhs) {
    parent.tid = rhs;
    assigned_qSetBit(parent, 37); // mark presence in pmask
}

// --- fasttest.FastState.Value49.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value49_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 7);
}

// --- fasttest.FastState.Value49.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value49_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 7); // mark presence in pmask
}

// --- fasttest.FastState.Value49.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value49_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 7;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value49.Set
inline void fasttest::Value49_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value49 = rhs;
    assigned_qSetBit(parent, 7); // mark presence in pmask
}

// --- fasttest.FastState.Value50.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value50_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 8);
}

// --- fasttest.FastState.Value50.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value50_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 3);
}

// --- fasttest.FastState.Value50.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value50_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 8); // mark presence in pmask
}

// --- fasttest.FastState.Value50.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value50_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 3); // mark presence in pmask
}

// --- fasttest.FastState.Value50.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value50_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 8;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value50.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value50_Present_GetBit(fasttest::FastState& parent) {
    int retval = 3;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value50.Set
inline void fasttest::Value50_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value50 = rhs;
    assigned_qSetBit(parent, 8); // mark presence in pmask
    present_qSetBit(parent, 3); // mark presence in pmask
}

// --- fasttest.FastState.Value51.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value51_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 9);
}

// --- fasttest.FastState.Value51.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value51_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 4);
}

// --- fasttest.FastState.Value51.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value51_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 9); // mark presence in pmask
}

// --- fasttest.FastState.Value51.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value51_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 4); // mark presence in pmask
}

// --- fasttest.FastState.Value51.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value51_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 9;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value51.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value51_Present_GetBit(fasttest::FastState& parent) {
    int retval = 4;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value51.Set
inline void fasttest::Value51_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value51 = rhs;
    assigned_qSetBit(parent, 9); // mark presence in pmask
    present_qSetBit(parent, 4); // mark presence in pmask
}

// --- fasttest.FastState.Value52.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value52_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 10);
}

// --- fasttest.FastState.Value52.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value52_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 10); // mark presence in pmask
}

// --- fasttest.FastState.Value52.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value52_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 10;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value52.Set
inline void fasttest::Value52_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value52 = rhs;
    assigned_qSetBit(parent, 10); // mark presence in pmask
}

// --- fasttest.FastState.Value53.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value53_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 11);
}

// --- fasttest.FastState.Value53.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value53_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 5);
}

// --- fasttest.FastState.Value53.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value53_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 11); // mark presence in pmask
}

// --- fasttest.FastState.Value53.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value53_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 5); // mark presence in pmask
}

// --- fasttest.FastState.Value53.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value53_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 11;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value53.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value53_Present_GetBit(fasttest::FastState& parent) {
    int retval = 5;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value53.Set
inline void fasttest::Value53_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value53 = rhs;
    assigned_qSetBit(parent, 11); // mark presence in pmask
    present_qSetBit(parent, 5); // mark presence in pmask
}

// --- fasttest.FastState.Value54.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value54_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 12);
}

// --- fasttest.FastState.Value54.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value54_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 6);
}

// --- fasttest.FastState.Value54.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value54_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 12); // mark presence in pmask
}

// --- fasttest.FastState.Value54.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value54_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 6); // mark presence in pmask
}

// --- fasttest.FastState.Value54.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value54_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 12;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value54.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value54_Present_GetBit(fasttest::FastState& parent) {
    int retval = 6;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value54.Set
inline void fasttest::Value54_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value54 = rhs;
    assigned_qSetBit(parent, 12); // mark presence in pmask
    present_qSetBit(parent, 6); // mark presence in pmask
}

// --- fasttest.FastState.Value55.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value55_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 13);
}

// --- fasttest.FastState.Value55.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value55_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 13); // mark presence in pmask
}

// --- fasttest.FastState.Value55.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value55_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 13;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value55.Set
inline void fasttest::Value55_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value55 = rhs;
    assigned_qSetBit(parent, 13); // mark presence in pmask
}

// --- fasttest.FastState.Value56.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value56_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 14);
}

// --- fasttest.FastState.Value56.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value56_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 7);
}

// --- fasttest.FastState.Value56.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value56_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 14); // mark presence in pmask
}

// --- fasttest.FastState.Value56.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value56_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 7); // mark presence in pmask
}

// --- fasttest.FastState.Value56.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value56_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 14;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value56.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value56_Present_GetBit(fasttest::FastState& parent) {
    int retval = 7;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value56.Set
inline void fasttest::Value56_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value56 = rhs;
    assigned_qSetBit(parent, 14); // mark presence in pmask
    present_qSetBit(parent, 7); // mark presence in pmask
}

// --- fasttest.FastState.Value57.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value57_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 15);
}

// --- fasttest.FastState.Value57.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value57_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 8);
}

// --- fasttest.FastState.Value57.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value57_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 15); // mark presence in pmask
}

// --- fasttest.FastState.Value57.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value57_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 8); // mark presence in pmask
}

// --- fasttest.FastState.Value57.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value57_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 15;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value57.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value57_Present_GetBit(fasttest::FastState& parent) {
    int retval = 8;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value57.Set
inline void fasttest::Value57_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value57 = rhs;
    assigned_qSetBit(parent, 15); // mark presence in pmask
    present_qSetBit(parent, 8); // mark presence in pmask
}

// --- fasttest.FastState.Value58.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value58_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 16);
}

// --- fasttest.FastState.Value58.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value58_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 16); // mark presence in pmask
}

// --- fasttest.FastState.Value58.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value58_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 16;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value58.Set
inline void fasttest::Value58_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value58 = rhs;
    assigned_qSetBit(parent, 16); // mark presence in pmask
}

// --- fasttest.FastState.Value59.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value59_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 17);
}

// --- fasttest.FastState.Value59.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value59_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 9);
}

// --- fasttest.FastState.Value59.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value59_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 17); // mark presence in pmask
}

// --- fasttest.FastState.Value59.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value59_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 9); // mark presence in pmask
}

// --- fasttest.FastState.Value59.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value59_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 17;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value59.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value59_Present_GetBit(fasttest::FastState& parent) {
    int retval = 9;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value59.Set
inline void fasttest::Value59_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value59 = rhs;
    assigned_qSetBit(parent, 17); // mark presence in pmask
    present_qSetBit(parent, 9); // mark presence in pmask
}

// --- fasttest.FastState.Value60.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value60_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 18);
}

// --- fasttest.FastState.Value60.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value60_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 10);
}

// --- fasttest.FastState.Value60.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value60_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 18); // mark presence in pmask
}

// --- fasttest.FastState.Value60.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value60_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 10); // mark presence in pmask
}

// --- fasttest.FastState.Value60.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value60_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 18;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value60.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value60_Present_GetBit(fasttest::FastState& parent) {
    int retval = 10;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value60.Set
inline void fasttest::Value60_Set(fasttest::FastState& parent, const algo::strptr& rhs) {
    parent.Value60 = rhs;
    assigned_qSetBit(parent, 18); // mark presence in pmask
    present_qSetBit(parent, 10); // mark presence in pmask
}

// --- fasttest.FastState.Value61.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value61_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 19);
}

// --- fasttest.FastState.Value61.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value61_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 19); // mark presence in pmask
}

// --- fasttest.FastState.Value61.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value61_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 19;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value61.Set
inline void fasttest::Value61_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value61 = rhs;
    assigned_qSetBit(parent, 19); // mark presence in pmask
}

// --- fasttest.FastState.Value62.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value62_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 20);
}

// --- fasttest.FastState.Value62.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value62_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 11);
}

// --- fasttest.FastState.Value62.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value62_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 20); // mark presence in pmask
}

// --- fasttest.FastState.Value62.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value62_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 11); // mark presence in pmask
}

// --- fasttest.FastState.Value62.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value62_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 20;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value62.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value62_Present_GetBit(fasttest::FastState& parent) {
    int retval = 11;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value62.Set
inline void fasttest::Value62_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value62 = rhs;
    assigned_qSetBit(parent, 20); // mark presence in pmask
    present_qSetBit(parent, 11); // mark presence in pmask
}

// --- fasttest.FastState.Value63.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value63_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 21);
}

// --- fasttest.FastState.Value63.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value63_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 12);
}

// --- fasttest.FastState.Value63.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value63_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 21); // mark presence in pmask
}

// --- fasttest.FastState.Value63.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value63_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 12); // mark presence in pmask
}

// --- fasttest.FastState.Value63.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value63_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 21;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value63.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value63_Present_GetBit(fasttest::FastState& parent) {
    int retval = 12;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value63.Set
inline void fasttest::Value63_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value63 = rhs;
    assigned_qSetBit(parent, 21); // mark presence in pmask
    present_qSetBit(parent, 12); // mark presence in pmask
}

// --- fasttest.FastState.Value65.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value65_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 22);
}

// --- fasttest.FastState.Value65.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value65_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 22); // mark presence in pmask
}

// --- fasttest.FastState.Value65.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value65_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 22;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value65.Set
inline void fasttest::Value65_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value65 = rhs;
    assigned_qSetBit(parent, 22); // mark presence in pmask
}

// --- fasttest.FastState.Value66.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value66_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 23);
}

// --- fasttest.FastState.Value66.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value66_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 23); // mark presence in pmask
}

// --- fasttest.FastState.Value66.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value66_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 23;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value66.Set
inline void fasttest::Value66_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value66 = rhs;
    assigned_qSetBit(parent, 23); // mark presence in pmask
}

// --- fasttest.FastState.Value67.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value67_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 24);
}

// --- fasttest.FastState.Value67.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value67_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 13);
}

// --- fasttest.FastState.Value67.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value67_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 24); // mark presence in pmask
}

// --- fasttest.FastState.Value67.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value67_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 13); // mark presence in pmask
}

// --- fasttest.FastState.Value67.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value67_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 24;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value67.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value67_Present_GetBit(fasttest::FastState& parent) {
    int retval = 13;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value67.Set
inline void fasttest::Value67_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value67 = rhs;
    assigned_qSetBit(parent, 24); // mark presence in pmask
    present_qSetBit(parent, 13); // mark presence in pmask
}

// --- fasttest.FastState.Value68.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value68_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 25);
}

// --- fasttest.FastState.Value68.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value68_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 14);
}

// --- fasttest.FastState.Value68.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value68_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 25); // mark presence in pmask
}

// --- fasttest.FastState.Value68.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value68_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 14); // mark presence in pmask
}

// --- fasttest.FastState.Value68.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value68_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 25;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value68.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value68_Present_GetBit(fasttest::FastState& parent) {
    int retval = 14;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value68.Set
inline void fasttest::Value68_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value68 = rhs;
    assigned_qSetBit(parent, 25); // mark presence in pmask
    present_qSetBit(parent, 14); // mark presence in pmask
}

// --- fasttest.FastState.Value69.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value69_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 26);
}

// --- fasttest.FastState.Value69.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value69_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 26); // mark presence in pmask
}

// --- fasttest.FastState.Value69.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value69_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 26;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value69.Set
inline void fasttest::Value69_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value69 = rhs;
    assigned_qSetBit(parent, 26); // mark presence in pmask
}

// --- fasttest.FastState.Value70.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value70_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 27);
}

// --- fasttest.FastState.Value70.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value70_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 27); // mark presence in pmask
}

// --- fasttest.FastState.Value70.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value70_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 27;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value70.Set
inline void fasttest::Value70_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value70 = rhs;
    assigned_qSetBit(parent, 27); // mark presence in pmask
}

// --- fasttest.FastState.Value71.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value71_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 28);
}

// --- fasttest.FastState.Value71.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value71_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 15);
}

// --- fasttest.FastState.Value71.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value71_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 28); // mark presence in pmask
}

// --- fasttest.FastState.Value71.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value71_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 15); // mark presence in pmask
}

// --- fasttest.FastState.Value71.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value71_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 28;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value71.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value71_Present_GetBit(fasttest::FastState& parent) {
    int retval = 15;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value71.Set
inline void fasttest::Value71_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value71 = rhs;
    assigned_qSetBit(parent, 28); // mark presence in pmask
    present_qSetBit(parent, 15); // mark presence in pmask
}

// --- fasttest.FastState.Value72.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value72_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 29);
}

// --- fasttest.FastState.Value72.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value72_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 16);
}

// --- fasttest.FastState.Value72.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value72_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 29); // mark presence in pmask
}

// --- fasttest.FastState.Value72.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value72_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 16); // mark presence in pmask
}

// --- fasttest.FastState.Value72.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value72_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 29;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value72.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value72_Present_GetBit(fasttest::FastState& parent) {
    int retval = 16;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value72.Set
inline void fasttest::Value72_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value72 = rhs;
    assigned_qSetBit(parent, 29); // mark presence in pmask
    present_qSetBit(parent, 16); // mark presence in pmask
}

// --- fasttest.FastState.Value81.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value81_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 30);
}

// --- fasttest.FastState.Value81.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value81_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 30); // mark presence in pmask
}

// --- fasttest.FastState.Value81.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value81_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 30;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value81.Set
inline void fasttest::Value81_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value81 = rhs;
    assigned_qSetBit(parent, 30); // mark presence in pmask
}

// --- fasttest.FastState.Value82.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value82_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 31);
}

// --- fasttest.FastState.Value82.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value82_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 31); // mark presence in pmask
}

// --- fasttest.FastState.Value82.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value82_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 31;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value82.Set
inline void fasttest::Value82_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value82 = rhs;
    assigned_qSetBit(parent, 31); // mark presence in pmask
}

// --- fasttest.FastState.Value83.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value83_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 32);
}

// --- fasttest.FastState.Value83.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value83_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 17);
}

// --- fasttest.FastState.Value83.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value83_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 32); // mark presence in pmask
}

// --- fasttest.FastState.Value83.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value83_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 17); // mark presence in pmask
}

// --- fasttest.FastState.Value83.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value83_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 32;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value83.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value83_Present_GetBit(fasttest::FastState& parent) {
    int retval = 17;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value83.Set
inline void fasttest::Value83_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value83 = rhs;
    assigned_qSetBit(parent, 32); // mark presence in pmask
    present_qSetBit(parent, 17); // mark presence in pmask
}

// --- fasttest.FastState.Value84.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value84_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 33);
}

// --- fasttest.FastState.Value84.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value84_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 18);
}

// --- fasttest.FastState.Value84.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value84_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 33); // mark presence in pmask
}

// --- fasttest.FastState.Value84.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value84_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 18); // mark presence in pmask
}

// --- fasttest.FastState.Value84.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value84_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 33;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value84.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value84_Present_GetBit(fasttest::FastState& parent) {
    int retval = 18;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value84.Set
inline void fasttest::Value84_Set(fasttest::FastState& parent, algo::Decimal rhs) {
    parent.Value84 = rhs;
    assigned_qSetBit(parent, 33); // mark presence in pmask
    present_qSetBit(parent, 18); // mark presence in pmask
}

// --- fasttest.FastState.Value97.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value97_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 34);
}

// --- fasttest.FastState.Value97.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value97_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 34); // mark presence in pmask
}

// --- fasttest.FastState.Value97.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value97_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 34;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value97.Set
inline void fasttest::Value97_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value97 = rhs;
    assigned_qSetBit(parent, 34); // mark presence in pmask
}

// --- fasttest.FastState.Value98.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value98_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 35);
}

// --- fasttest.FastState.Value98.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value98_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 35); // mark presence in pmask
}

// --- fasttest.FastState.Value98.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value98_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 35;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value98.Set
inline void fasttest::Value98_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value98 = rhs;
    assigned_qSetBit(parent, 35); // mark presence in pmask
}

// --- fasttest.FastState.Value99.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value99_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 36);
}

// --- fasttest.FastState.Value99.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value99_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 19);
}

// --- fasttest.FastState.Value99.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value99_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 36); // mark presence in pmask
}

// --- fasttest.FastState.Value99.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value99_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 19); // mark presence in pmask
}

// --- fasttest.FastState.Value99.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value99_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 36;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value99.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value99_Present_GetBit(fasttest::FastState& parent) {
    int retval = 19;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value99.Set
inline void fasttest::Value99_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value99 = rhs;
    assigned_qSetBit(parent, 36); // mark presence in pmask
    present_qSetBit(parent, 19); // mark presence in pmask
}

// --- fasttest.FastState.Value100.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value100_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 0);
}

// --- fasttest.FastState.Value100.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value100_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 0);
}

// --- fasttest.FastState.Value100.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value100_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.FastState.Value100.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value100_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.FastState.Value100.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value100_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value100.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value100_Present_GetBit(fasttest::FastState& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value100.Set
inline void fasttest::Value100_Set(fasttest::FastState& parent, i32 rhs) {
    parent.Value100 = rhs;
    assigned_qSetBit(parent, 0); // mark presence in pmask
    present_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.FastState.Value101.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value101_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 1);
}

// --- fasttest.FastState.Value101.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value101_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 1); // mark presence in pmask
}

// --- fasttest.FastState.Value101.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value101_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 1;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value101.Set
inline void fasttest::Value101_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value101 = rhs;
    assigned_qSetBit(parent, 1); // mark presence in pmask
}

// --- fasttest.FastState.Value102.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value102_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 2);
}

// --- fasttest.FastState.Value102.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value102_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 2); // mark presence in pmask
}

// --- fasttest.FastState.Value102.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value102_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 2;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value102.Set
inline void fasttest::Value102_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value102 = rhs;
    assigned_qSetBit(parent, 2); // mark presence in pmask
}

// --- fasttest.FastState.Value103.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value103_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 3);
}

// --- fasttest.FastState.Value103.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value103_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 1);
}

// --- fasttest.FastState.Value103.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value103_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 3); // mark presence in pmask
}

// --- fasttest.FastState.Value103.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value103_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 1); // mark presence in pmask
}

// --- fasttest.FastState.Value103.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value103_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 3;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value103.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value103_Present_GetBit(fasttest::FastState& parent) {
    int retval = 1;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value103.Set
inline void fasttest::Value103_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value103 = rhs;
    assigned_qSetBit(parent, 3); // mark presence in pmask
    present_qSetBit(parent, 1); // mark presence in pmask
}

// --- fasttest.FastState.Value104.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value104_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 4);
}

// --- fasttest.FastState.Value104.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value104_PresentQ(fasttest::FastState& parent) {
    return present_qGetBit(parent, 2);
}

// --- fasttest.FastState.Value104.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value104_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 4); // mark presence in pmask
}

// --- fasttest.FastState.Value104.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value104_SetPresent(fasttest::FastState& parent) {
    present_qSetBit(parent, 2); // mark presence in pmask
}

// --- fasttest.FastState.Value104.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value104_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 4;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value104.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value104_Present_GetBit(fasttest::FastState& parent) {
    int retval = 2;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value104.Set
inline void fasttest::Value104_Set(fasttest::FastState& parent, u32 rhs) {
    parent.Value104 = rhs;
    assigned_qSetBit(parent, 4); // mark presence in pmask
    present_qSetBit(parent, 2); // mark presence in pmask
}

// --- fasttest.FastState.Value147.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value147_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 5);
}

// --- fasttest.FastState.Value147.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value147_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 5); // mark presence in pmask
}

// --- fasttest.FastState.Value147.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value147_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 5;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value147.Set
inline void fasttest::Value147_Set(fasttest::FastState& parent, fasttest::SampleEnum rhs) {
    parent.Value147 = rhs;
    assigned_qSetBit(parent, 5); // mark presence in pmask
}

// --- fasttest.FastState.Value150.AssignedQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value150_AssignedQ(fasttest::FastState& parent) {
    return assigned_qGetBit(parent, 6);
}

// --- fasttest.FastState.Value150.SetAssigned
// Set presence bit for this field in the pmask
inline void fasttest::Value150_SetAssigned(fasttest::FastState& parent) {
    assigned_qSetBit(parent, 6); // mark presence in pmask
}

// --- fasttest.FastState.Value150.Assigned_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value150_Assigned_GetBit(fasttest::FastState& parent) {
    int retval = 6;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.FastState.Value150.Set
inline void fasttest::Value150_Set(fasttest::FastState& parent, fasttest::SampleSet rhs) {
    parent.Value150 = rhs;
    assigned_qSetBit(parent, 6); // mark presence in pmask
}

// --- fasttest.FastState.assigned_bitcurs.Reset
inline void fasttest::FastState_assigned_bitcurs_Reset(FastState_assigned_bitcurs &curs, fasttest::FastState &parent) {
    curs.elems = &assigned_qFind(parent,0);
    curs.n_elems = assigned_N(parent);
    curs.bit = -1;
    FastState_assigned_bitcurs_Next(curs);
}

// --- fasttest.FastState.assigned_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::FastState_assigned_bitcurs_ValidQ(FastState_assigned_bitcurs &curs) {
    return curs.bit < curs.n_elems*64;
}

// --- fasttest.FastState.assigned_bitcurs.Access
// item access
inline int& fasttest::FastState_assigned_bitcurs_Access(FastState_assigned_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.FastState.present_bitcurs.Reset
inline void fasttest::FastState_present_bitcurs_Reset(FastState_present_bitcurs &curs, fasttest::FastState &parent) {
    curs.elems = &present_qFind(parent,0);
    curs.n_elems = present_N(parent);
    curs.bit = -1;
    FastState_present_bitcurs_Next(curs);
}

// --- fasttest.FastState.present_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::FastState_present_bitcurs_ValidQ(FastState_present_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.FastState.present_bitcurs.Access
// item access
inline int& fasttest::FastState_present_bitcurs_Access(FastState_present_bitcurs &curs) {
    return curs.bit;
}
inline fasttest::FieldId::FieldId(i32                            in_value)
    : value(in_value)
{
}
inline fasttest::FieldId::FieldId(fasttest_FieldIdEnum arg) { this->value = i32(arg); }
inline fasttest::FieldId::FieldId() {
    fasttest::FieldId_Init(*this);
}


// --- fasttest.FieldId.value.GetEnum
// Get value of field as enum type
inline fasttest_FieldIdEnum fasttest::value_GetEnum(const fasttest::FieldId& parent) {
    return fasttest_FieldIdEnum(parent.value);
}

// --- fasttest.FieldId.value.SetEnum
// Set value of field from enum type.
inline void fasttest::value_SetEnum(fasttest::FieldId& parent, fasttest_FieldIdEnum rhs) {
    parent.value = i32(rhs);
}

// --- fasttest.FieldId.value.Cast
inline fasttest::FieldId::operator fasttest_FieldIdEnum () const {
    return fasttest_FieldIdEnum((*this).value);
}

// --- fasttest.FieldId..Init
// Set all fields to initial values.
inline void fasttest::FieldId_Init(fasttest::FieldId& parent) {
    parent.value = i32(-1);
}
inline fasttest::FirstSeq::FirstSeq() {
    fasttest::FirstSeq_Init(*this);
}


// --- fasttest.FirstSeq..Init
// Set all fields to initial values.
inline void fasttest::FirstSeq_Init(fasttest::FirstSeq& FirstSeq) {
    FirstSeq.Value1 = u32(0);
}
inline fasttest::OptSgmGrp::OptSgmGrp() {
    fasttest::OptSgmGrp_Init(*this);
}


// --- fasttest.OptSgmGrp..Init
// Set all fields to initial values.
inline void fasttest::OptSgmGrp_Init(fasttest::OptSgmGrp& parent) {
    parent.Value = u32(1);
}
inline fasttest::GroupSgmOpt::GroupSgmOpt() {
    fasttest::GroupSgmOpt_Init(*this);
}


// --- fasttest.GroupSgmOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of GroupSgmOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of GroupSgmOpt.
// If not successful, quietly return NULL.
inline fasttest::GroupSgmOpt* fasttest::GroupSgmOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (115);
    cond &= i32(hdr.length) >= ssizeof(fasttest::GroupSgmOpt);
    return cond ? reinterpret_cast<fasttest::GroupSgmOpt*>(&hdr) : NULL;
}

// --- fasttest.GroupSgmOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::GroupSgmOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.GroupSgmOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::GroupSgmOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.GroupSgmOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::GroupSgmOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.GroupSgmOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::GroupSgmOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.GroupSgmOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.GroupSgmOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.GroupSgmOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::GroupSgmOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.GroupSgmOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::GroupSgmOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.GroupSgmOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.GroupSgmOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.GroupSgmOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.GroupSgmOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::GroupSgmOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.GroupSgmOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::GroupSgmOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.GroupSgmOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::GroupSgmOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.GroupSgmOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::GroupSgmOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.GroupSgmOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::GroupSgmOpt& parent, fasttest::GroupSgmOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.GroupSgmOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::GroupSgmOpt& parent, fasttest::GroupSgmOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.GroupSgmOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::GroupSgmOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.GroupSgmOpt.OptSgmGrp.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::OptSgmGrp_PresentQ(fasttest::GroupSgmOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.GroupSgmOpt.OptSgmGrp.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::OptSgmGrp_SetPresent(fasttest::GroupSgmOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.GroupSgmOpt.OptSgmGrp.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::OptSgmGrp_Present_GetBit(fasttest::GroupSgmOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.GroupSgmOpt.OptSgmGrp.Set
inline void fasttest::OptSgmGrp_Set(fasttest::GroupSgmOpt& parent, const fasttest::OptSgmGrp& rhs) {
    parent.OptSgmGrp = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.GroupSgmOpt.pmask_bitcurs.Reset
inline void fasttest::GroupSgmOpt_pmask_bitcurs_Reset(GroupSgmOpt_pmask_bitcurs &curs, fasttest::GroupSgmOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    GroupSgmOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.GroupSgmOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::GroupSgmOpt_pmask_bitcurs_ValidQ(GroupSgmOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.GroupSgmOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::GroupSgmOpt_pmask_bitcurs_Access(GroupSgmOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.GroupSgmOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::GroupSgmOpt& parent) {
    return i32(const_cast<fasttest::GroupSgmOpt&>(parent).length);
}

// --- fasttest.GroupSgmOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::GroupSgmOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::GroupSgmOpt&>(row).length));
}

// --- fasttest.GroupSgmOpt..Init
// Set all fields to initial values.
inline void fasttest::GroupSgmOpt_Init(fasttest::GroupSgmOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(115);
    parent.pmask = u32(0);
}
inline fasttest::TrvGrp::TrvGrp() {
    fasttest::TrvGrp_Init(*this);
}


// --- fasttest.TrvGrp..Init
// Set all fields to initial values.
inline void fasttest::TrvGrp_Init(fasttest::TrvGrp& parent) {
    parent.Value = u32(0);
}
inline fasttest::GroupTrv::GroupTrv() {
    fasttest::GroupTrv_Init(*this);
}


// --- fasttest.GroupTrv.base.Castdown
// Check if fasttest::TemplateHeader is an instance of GroupTrv by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of GroupTrv.
// If not successful, quietly return NULL.
inline fasttest::GroupTrv* fasttest::GroupTrv_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (113);
    cond &= i32(hdr.length) >= ssizeof(fasttest::GroupTrv);
    return cond ? reinterpret_cast<fasttest::GroupTrv*>(&hdr) : NULL;
}

// --- fasttest.GroupTrv.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::GroupTrv& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.GroupTrv..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::GroupTrv& parent) {
    return i32(const_cast<fasttest::GroupTrv&>(parent).length);
}

// --- fasttest.GroupTrv..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::GroupTrv& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::GroupTrv&>(row).length));
}

// --- fasttest.GroupTrv..Init
// Set all fields to initial values.
inline void fasttest::GroupTrv_Init(fasttest::GroupTrv& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(113);
}
inline fasttest::OptTrvGrp::OptTrvGrp() {
    fasttest::OptTrvGrp_Init(*this);
}


// --- fasttest.OptTrvGrp..Init
// Set all fields to initial values.
inline void fasttest::OptTrvGrp_Init(fasttest::OptTrvGrp& parent) {
    parent.Value = u32(0);
}
inline fasttest::GroupTrvOpt::GroupTrvOpt() {
    fasttest::GroupTrvOpt_Init(*this);
}


// --- fasttest.GroupTrvOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of GroupTrvOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of GroupTrvOpt.
// If not successful, quietly return NULL.
inline fasttest::GroupTrvOpt* fasttest::GroupTrvOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (114);
    cond &= i32(hdr.length) >= ssizeof(fasttest::GroupTrvOpt);
    return cond ? reinterpret_cast<fasttest::GroupTrvOpt*>(&hdr) : NULL;
}

// --- fasttest.GroupTrvOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::GroupTrvOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.GroupTrvOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::GroupTrvOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.GroupTrvOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::GroupTrvOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.GroupTrvOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::GroupTrvOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.GroupTrvOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.GroupTrvOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.GroupTrvOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::GroupTrvOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.GroupTrvOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::GroupTrvOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.GroupTrvOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.GroupTrvOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.GroupTrvOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.GroupTrvOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::GroupTrvOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.GroupTrvOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::GroupTrvOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.GroupTrvOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::GroupTrvOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.GroupTrvOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::GroupTrvOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.GroupTrvOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::GroupTrvOpt& parent, fasttest::GroupTrvOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.GroupTrvOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::GroupTrvOpt& parent, fasttest::GroupTrvOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.GroupTrvOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::GroupTrvOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.GroupTrvOpt.OptTrvGrp.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::OptTrvGrp_PresentQ(fasttest::GroupTrvOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.GroupTrvOpt.OptTrvGrp.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::OptTrvGrp_SetPresent(fasttest::GroupTrvOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.GroupTrvOpt.OptTrvGrp.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::OptTrvGrp_Present_GetBit(fasttest::GroupTrvOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.GroupTrvOpt.OptTrvGrp.Set
inline void fasttest::OptTrvGrp_Set(fasttest::GroupTrvOpt& parent, const fasttest::OptTrvGrp& rhs) {
    parent.OptTrvGrp = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.GroupTrvOpt.pmask_bitcurs.Reset
inline void fasttest::GroupTrvOpt_pmask_bitcurs_Reset(GroupTrvOpt_pmask_bitcurs &curs, fasttest::GroupTrvOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    GroupTrvOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.GroupTrvOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::GroupTrvOpt_pmask_bitcurs_ValidQ(GroupTrvOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.GroupTrvOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::GroupTrvOpt_pmask_bitcurs_Access(GroupTrvOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.GroupTrvOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::GroupTrvOpt& parent) {
    return i32(const_cast<fasttest::GroupTrvOpt&>(parent).length);
}

// --- fasttest.GroupTrvOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::GroupTrvOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::GroupTrvOpt&>(row).length));
}

// --- fasttest.GroupTrvOpt..Init
// Set all fields to initial values.
inline void fasttest::GroupTrvOpt_Init(fasttest::GroupTrvOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(114);
    parent.pmask = u32(0);
}
inline fasttest::I32Const::I32Const() {
    fasttest::I32Const_Init(*this);
}


// --- fasttest.I32Const.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32Const by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32Const.
// If not successful, quietly return NULL.
inline fasttest::I32Const* fasttest::I32Const_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (17);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32Const);
    return cond ? reinterpret_cast<fasttest::I32Const*>(&hdr) : NULL;
}

// --- fasttest.I32Const.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32Const& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32Const.Value.Get
inline i32 fasttest::Value_Get(fasttest::I32Const& parent) {
    (void)parent;
    return i32(17);
}

// --- fasttest.I32Const..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32Const& parent) {
    return i32(const_cast<fasttest::I32Const&>(parent).length);
}

// --- fasttest.I32Const..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32Const& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32Const&>(row).length));
}

// --- fasttest.I32Const..Init
// Set all fields to initial values.
inline void fasttest::I32Const_Init(fasttest::I32Const& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(17);
}
inline fasttest::I32ConstOpt::I32ConstOpt() {
    fasttest::I32ConstOpt_Init(*this);
}


// --- fasttest.I32ConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32ConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32ConstOpt.
// If not successful, quietly return NULL.
inline fasttest::I32ConstOpt* fasttest::I32ConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (18);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32ConstOpt);
    return cond ? reinterpret_cast<fasttest::I32ConstOpt*>(&hdr) : NULL;
}

// --- fasttest.I32ConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32ConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32ConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32ConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32ConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32ConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32ConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32ConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32ConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32ConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32ConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32ConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32ConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32ConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32ConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32ConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32ConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32ConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32ConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32ConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32ConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32ConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32ConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32ConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32ConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32ConstOpt& parent, fasttest::I32ConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32ConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32ConstOpt& parent, fasttest::I32ConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32ConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32ConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32ConstOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::I32ConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32ConstOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::I32ConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32ConstOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::I32ConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32ConstOpt.Value.Get
inline i32 fasttest::Value_Get(fasttest::I32ConstOpt& parent) {
    (void)parent;
    return i32(18);
}

// --- fasttest.I32ConstOpt.pmask_bitcurs.Reset
inline void fasttest::I32ConstOpt_pmask_bitcurs_Reset(I32ConstOpt_pmask_bitcurs &curs, fasttest::I32ConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32ConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32ConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32ConstOpt_pmask_bitcurs_ValidQ(I32ConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32ConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32ConstOpt_pmask_bitcurs_Access(I32ConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32ConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32ConstOpt& parent) {
    return i32(const_cast<fasttest::I32ConstOpt&>(parent).length);
}

// --- fasttest.I32ConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32ConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32ConstOpt&>(row).length));
}

// --- fasttest.I32ConstOpt..Init
// Set all fields to initial values.
inline void fasttest::I32ConstOpt_Init(fasttest::I32ConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(18);
    parent.pmask = u32(0);
}
inline fasttest::I32Copy::I32Copy() {
    fasttest::I32Copy_Init(*this);
}


// --- fasttest.I32Copy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32Copy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32Copy.
// If not successful, quietly return NULL.
inline fasttest::I32Copy* fasttest::I32Copy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (49);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32Copy);
    return cond ? reinterpret_cast<fasttest::I32Copy*>(&hdr) : NULL;
}

// --- fasttest.I32Copy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32Copy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32Copy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32Copy& parent) {
    return i32(const_cast<fasttest::I32Copy&>(parent).length);
}

// --- fasttest.I32Copy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32Copy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32Copy&>(row).length));
}

// --- fasttest.I32Copy..Init
// Set all fields to initial values.
inline void fasttest::I32Copy_Init(fasttest::I32Copy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(49);
    parent.Value49 = i32(49);
}
inline fasttest::I32CopyNull::I32CopyNull() {
    fasttest::I32CopyNull_Init(*this);
}


// --- fasttest.I32CopyNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32CopyNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32CopyNull.
// If not successful, quietly return NULL.
inline fasttest::I32CopyNull* fasttest::I32CopyNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (51);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32CopyNull);
    return cond ? reinterpret_cast<fasttest::I32CopyNull*>(&hdr) : NULL;
}

// --- fasttest.I32CopyNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32CopyNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32CopyNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32CopyNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32CopyNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32CopyNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32CopyNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32CopyNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32CopyNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32CopyNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32CopyNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32CopyNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32CopyNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32CopyNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32CopyNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32CopyNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32CopyNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32CopyNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32CopyNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32CopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32CopyNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32CopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32CopyNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32CopyNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32CopyNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32CopyNull& parent, fasttest::I32CopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32CopyNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32CopyNull& parent, fasttest::I32CopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32CopyNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32CopyNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32CopyNull.Value51.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value51_PresentQ(fasttest::I32CopyNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32CopyNull.Value51.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value51_SetPresent(fasttest::I32CopyNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32CopyNull.Value51.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value51_Present_GetBit(fasttest::I32CopyNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32CopyNull.Value51.Set
inline void fasttest::Value51_Set(fasttest::I32CopyNull& parent, i32 rhs) {
    parent.Value51 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32CopyNull.pmask_bitcurs.Reset
inline void fasttest::I32CopyNull_pmask_bitcurs_Reset(I32CopyNull_pmask_bitcurs &curs, fasttest::I32CopyNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32CopyNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32CopyNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32CopyNull_pmask_bitcurs_ValidQ(I32CopyNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32CopyNull.pmask_bitcurs.Access
// item access
inline int& fasttest::I32CopyNull_pmask_bitcurs_Access(I32CopyNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32CopyNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32CopyNull& parent) {
    return i32(const_cast<fasttest::I32CopyNull&>(parent).length);
}

// --- fasttest.I32CopyNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32CopyNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32CopyNull&>(row).length));
}

// --- fasttest.I32CopyNull..Init
// Set all fields to initial values.
inline void fasttest::I32CopyNull_Init(fasttest::I32CopyNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(51);
    parent.pmask = u32(0);
    parent.Value51 = i32(0);
}
inline fasttest::I32CopyOpt::I32CopyOpt() {
    fasttest::I32CopyOpt_Init(*this);
}


// --- fasttest.I32CopyOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32CopyOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32CopyOpt.
// If not successful, quietly return NULL.
inline fasttest::I32CopyOpt* fasttest::I32CopyOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (50);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32CopyOpt);
    return cond ? reinterpret_cast<fasttest::I32CopyOpt*>(&hdr) : NULL;
}

// --- fasttest.I32CopyOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32CopyOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32CopyOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32CopyOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32CopyOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32CopyOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32CopyOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32CopyOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32CopyOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32CopyOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32CopyOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32CopyOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32CopyOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32CopyOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32CopyOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32CopyOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32CopyOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32CopyOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32CopyOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32CopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32CopyOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32CopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32CopyOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32CopyOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32CopyOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32CopyOpt& parent, fasttest::I32CopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32CopyOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32CopyOpt& parent, fasttest::I32CopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32CopyOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32CopyOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32CopyOpt.Value50.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value50_PresentQ(fasttest::I32CopyOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32CopyOpt.Value50.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value50_SetPresent(fasttest::I32CopyOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32CopyOpt.Value50.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value50_Present_GetBit(fasttest::I32CopyOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32CopyOpt.Value50.Set
inline void fasttest::Value50_Set(fasttest::I32CopyOpt& parent, i32 rhs) {
    parent.Value50 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32CopyOpt.pmask_bitcurs.Reset
inline void fasttest::I32CopyOpt_pmask_bitcurs_Reset(I32CopyOpt_pmask_bitcurs &curs, fasttest::I32CopyOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32CopyOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32CopyOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32CopyOpt_pmask_bitcurs_ValidQ(I32CopyOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32CopyOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32CopyOpt_pmask_bitcurs_Access(I32CopyOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32CopyOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32CopyOpt& parent) {
    return i32(const_cast<fasttest::I32CopyOpt&>(parent).length);
}

// --- fasttest.I32CopyOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32CopyOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32CopyOpt&>(row).length));
}

// --- fasttest.I32CopyOpt..Init
// Set all fields to initial values.
inline void fasttest::I32CopyOpt_Init(fasttest::I32CopyOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(50);
    parent.pmask = u32(0);
    parent.Value50 = i32(50);
}
inline fasttest::I32Delta::I32Delta() {
    fasttest::I32Delta_Init(*this);
}


// --- fasttest.I32Delta.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32Delta by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32Delta.
// If not successful, quietly return NULL.
inline fasttest::I32Delta* fasttest::I32Delta_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (65);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32Delta);
    return cond ? reinterpret_cast<fasttest::I32Delta*>(&hdr) : NULL;
}

// --- fasttest.I32Delta.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32Delta& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32Delta..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32Delta& parent) {
    return i32(const_cast<fasttest::I32Delta&>(parent).length);
}

// --- fasttest.I32Delta..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32Delta& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32Delta&>(row).length));
}

// --- fasttest.I32Delta..Init
// Set all fields to initial values.
inline void fasttest::I32Delta_Init(fasttest::I32Delta& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(65);
    parent.Value65 = i32(65);
}
inline fasttest::I32DeltaImpl::I32DeltaImpl() {
    fasttest::I32DeltaImpl_Init(*this);
}


// --- fasttest.I32DeltaImpl.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32DeltaImpl by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32DeltaImpl.
// If not successful, quietly return NULL.
inline fasttest::I32DeltaImpl* fasttest::I32DeltaImpl_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (66);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32DeltaImpl);
    return cond ? reinterpret_cast<fasttest::I32DeltaImpl*>(&hdr) : NULL;
}

// --- fasttest.I32DeltaImpl.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32DeltaImpl& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32DeltaImpl..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32DeltaImpl& parent) {
    return i32(const_cast<fasttest::I32DeltaImpl&>(parent).length);
}

// --- fasttest.I32DeltaImpl..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32DeltaImpl& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32DeltaImpl&>(row).length));
}

// --- fasttest.I32DeltaImpl..Init
// Set all fields to initial values.
inline void fasttest::I32DeltaImpl_Init(fasttest::I32DeltaImpl& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(66);
    parent.Value66 = i32(0);
}
inline fasttest::I32DeltaNull::I32DeltaNull() {
    fasttest::I32DeltaNull_Init(*this);
}


// --- fasttest.I32DeltaNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32DeltaNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32DeltaNull.
// If not successful, quietly return NULL.
inline fasttest::I32DeltaNull* fasttest::I32DeltaNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (68);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32DeltaNull);
    return cond ? reinterpret_cast<fasttest::I32DeltaNull*>(&hdr) : NULL;
}

// --- fasttest.I32DeltaNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32DeltaNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32DeltaNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32DeltaNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32DeltaNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32DeltaNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32DeltaNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32DeltaNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32DeltaNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32DeltaNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32DeltaNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32DeltaNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32DeltaNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32DeltaNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32DeltaNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32DeltaNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32DeltaNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32DeltaNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32DeltaNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32DeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32DeltaNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32DeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32DeltaNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32DeltaNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32DeltaNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32DeltaNull& parent, fasttest::I32DeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DeltaNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32DeltaNull& parent, fasttest::I32DeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DeltaNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32DeltaNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32DeltaNull.Value68.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value68_PresentQ(fasttest::I32DeltaNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32DeltaNull.Value68.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value68_SetPresent(fasttest::I32DeltaNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DeltaNull.Value68.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value68_Present_GetBit(fasttest::I32DeltaNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32DeltaNull.Value68.Set
inline void fasttest::Value68_Set(fasttest::I32DeltaNull& parent, i32 rhs) {
    parent.Value68 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DeltaNull.pmask_bitcurs.Reset
inline void fasttest::I32DeltaNull_pmask_bitcurs_Reset(I32DeltaNull_pmask_bitcurs &curs, fasttest::I32DeltaNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32DeltaNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32DeltaNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32DeltaNull_pmask_bitcurs_ValidQ(I32DeltaNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32DeltaNull.pmask_bitcurs.Access
// item access
inline int& fasttest::I32DeltaNull_pmask_bitcurs_Access(I32DeltaNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32DeltaNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32DeltaNull& parent) {
    return i32(const_cast<fasttest::I32DeltaNull&>(parent).length);
}

// --- fasttest.I32DeltaNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32DeltaNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32DeltaNull&>(row).length));
}

// --- fasttest.I32DeltaNull..Init
// Set all fields to initial values.
inline void fasttest::I32DeltaNull_Init(fasttest::I32DeltaNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(68);
    parent.pmask = u32(0);
    parent.Value68 = i32(0);
}
inline fasttest::I32DeltaOpt::I32DeltaOpt() {
    fasttest::I32DeltaOpt_Init(*this);
}


// --- fasttest.I32DeltaOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32DeltaOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32DeltaOpt.
// If not successful, quietly return NULL.
inline fasttest::I32DeltaOpt* fasttest::I32DeltaOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (67);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32DeltaOpt);
    return cond ? reinterpret_cast<fasttest::I32DeltaOpt*>(&hdr) : NULL;
}

// --- fasttest.I32DeltaOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32DeltaOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32DeltaOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32DeltaOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32DeltaOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32DeltaOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32DeltaOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32DeltaOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32DeltaOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32DeltaOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32DeltaOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32DeltaOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32DeltaOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32DeltaOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32DeltaOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32DeltaOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32DeltaOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32DeltaOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32DeltaOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32DeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32DeltaOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32DeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32DeltaOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32DeltaOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32DeltaOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32DeltaOpt& parent, fasttest::I32DeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DeltaOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32DeltaOpt& parent, fasttest::I32DeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DeltaOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32DeltaOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32DeltaOpt.Value67.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value67_PresentQ(fasttest::I32DeltaOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32DeltaOpt.Value67.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value67_SetPresent(fasttest::I32DeltaOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DeltaOpt.Value67.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value67_Present_GetBit(fasttest::I32DeltaOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32DeltaOpt.Value67.Set
inline void fasttest::Value67_Set(fasttest::I32DeltaOpt& parent, i32 rhs) {
    parent.Value67 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DeltaOpt.pmask_bitcurs.Reset
inline void fasttest::I32DeltaOpt_pmask_bitcurs_Reset(I32DeltaOpt_pmask_bitcurs &curs, fasttest::I32DeltaOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32DeltaOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32DeltaOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32DeltaOpt_pmask_bitcurs_ValidQ(I32DeltaOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32DeltaOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32DeltaOpt_pmask_bitcurs_Access(I32DeltaOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32DeltaOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32DeltaOpt& parent) {
    return i32(const_cast<fasttest::I32DeltaOpt&>(parent).length);
}

// --- fasttest.I32DeltaOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32DeltaOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32DeltaOpt&>(row).length));
}

// --- fasttest.I32DeltaOpt..Init
// Set all fields to initial values.
inline void fasttest::I32DeltaOpt_Init(fasttest::I32DeltaOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(67);
    parent.pmask = u32(0);
    parent.Value67 = i32(67);
}
inline fasttest::I32Dflt::I32Dflt() {
    fasttest::I32Dflt_Init(*this);
}


// --- fasttest.I32Dflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32Dflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32Dflt.
// If not successful, quietly return NULL.
inline fasttest::I32Dflt* fasttest::I32Dflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (33);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32Dflt);
    return cond ? reinterpret_cast<fasttest::I32Dflt*>(&hdr) : NULL;
}

// --- fasttest.I32Dflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32Dflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32Dflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32Dflt& parent) {
    return i32(const_cast<fasttest::I32Dflt&>(parent).length);
}

// --- fasttest.I32Dflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32Dflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32Dflt&>(row).length));
}

// --- fasttest.I32Dflt..Init
// Set all fields to initial values.
inline void fasttest::I32Dflt_Init(fasttest::I32Dflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(33);
    parent.Value = i32(33);
}
inline fasttest::I32DfltNull::I32DfltNull() {
    fasttest::I32DfltNull_Init(*this);
}


// --- fasttest.I32DfltNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32DfltNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32DfltNull.
// If not successful, quietly return NULL.
inline fasttest::I32DfltNull* fasttest::I32DfltNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (35);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32DfltNull);
    return cond ? reinterpret_cast<fasttest::I32DfltNull*>(&hdr) : NULL;
}

// --- fasttest.I32DfltNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32DfltNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32DfltNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32DfltNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32DfltNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32DfltNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32DfltNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32DfltNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32DfltNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32DfltNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32DfltNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32DfltNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32DfltNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32DfltNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32DfltNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32DfltNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32DfltNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32DfltNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32DfltNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32DfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32DfltNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32DfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32DfltNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32DfltNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32DfltNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32DfltNull& parent, fasttest::I32DfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DfltNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32DfltNull& parent, fasttest::I32DfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DfltNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32DfltNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32DfltNull.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::I32DfltNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32DfltNull.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::I32DfltNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DfltNull.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::I32DfltNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32DfltNull.Value.Set
inline void fasttest::Value_Set(fasttest::I32DfltNull& parent, i32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DfltNull.pmask_bitcurs.Reset
inline void fasttest::I32DfltNull_pmask_bitcurs_Reset(I32DfltNull_pmask_bitcurs &curs, fasttest::I32DfltNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32DfltNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32DfltNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32DfltNull_pmask_bitcurs_ValidQ(I32DfltNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32DfltNull.pmask_bitcurs.Access
// item access
inline int& fasttest::I32DfltNull_pmask_bitcurs_Access(I32DfltNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32DfltNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32DfltNull& parent) {
    return i32(const_cast<fasttest::I32DfltNull&>(parent).length);
}

// --- fasttest.I32DfltNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32DfltNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32DfltNull&>(row).length));
}

// --- fasttest.I32DfltNull..Init
// Set all fields to initial values.
inline void fasttest::I32DfltNull_Init(fasttest::I32DfltNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(35);
    parent.pmask = u32(0);
    parent.Value = i32(0);
}
inline fasttest::I32DfltOpt::I32DfltOpt() {
    fasttest::I32DfltOpt_Init(*this);
}


// --- fasttest.I32DfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32DfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32DfltOpt.
// If not successful, quietly return NULL.
inline fasttest::I32DfltOpt* fasttest::I32DfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (34);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32DfltOpt);
    return cond ? reinterpret_cast<fasttest::I32DfltOpt*>(&hdr) : NULL;
}

// --- fasttest.I32DfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32DfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32DfltOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32DfltOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32DfltOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32DfltOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32DfltOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32DfltOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32DfltOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32DfltOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32DfltOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32DfltOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32DfltOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32DfltOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32DfltOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32DfltOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32DfltOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32DfltOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32DfltOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32DfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32DfltOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32DfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32DfltOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32DfltOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32DfltOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32DfltOpt& parent, fasttest::I32DfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DfltOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32DfltOpt& parent, fasttest::I32DfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32DfltOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32DfltOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32DfltOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::I32DfltOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32DfltOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::I32DfltOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DfltOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::I32DfltOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32DfltOpt.Value.Set
inline void fasttest::Value_Set(fasttest::I32DfltOpt& parent, i32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32DfltOpt.pmask_bitcurs.Reset
inline void fasttest::I32DfltOpt_pmask_bitcurs_Reset(I32DfltOpt_pmask_bitcurs &curs, fasttest::I32DfltOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32DfltOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32DfltOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32DfltOpt_pmask_bitcurs_ValidQ(I32DfltOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32DfltOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32DfltOpt_pmask_bitcurs_Access(I32DfltOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32DfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32DfltOpt& parent) {
    return i32(const_cast<fasttest::I32DfltOpt&>(parent).length);
}

// --- fasttest.I32DfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32DfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32DfltOpt&>(row).length));
}

// --- fasttest.I32DfltOpt..Init
// Set all fields to initial values.
inline void fasttest::I32DfltOpt_Init(fasttest::I32DfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(34);
    parent.pmask = u32(0);
    parent.Value = i32(34);
}
inline fasttest::I32Incr::I32Incr() {
    fasttest::I32Incr_Init(*this);
}


// --- fasttest.I32Incr.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32Incr by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32Incr.
// If not successful, quietly return NULL.
inline fasttest::I32Incr* fasttest::I32Incr_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (97);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32Incr);
    return cond ? reinterpret_cast<fasttest::I32Incr*>(&hdr) : NULL;
}

// --- fasttest.I32Incr.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32Incr& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32Incr..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32Incr& parent) {
    return i32(const_cast<fasttest::I32Incr&>(parent).length);
}

// --- fasttest.I32Incr..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32Incr& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32Incr&>(row).length));
}

// --- fasttest.I32Incr..Init
// Set all fields to initial values.
inline void fasttest::I32Incr_Init(fasttest::I32Incr& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(97);
    parent.Value97 = i32(97);
}
inline fasttest::I32IncrNV::I32IncrNV() {
    fasttest::I32IncrNV_Init(*this);
}


// --- fasttest.I32IncrNV.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32IncrNV by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32IncrNV.
// If not successful, quietly return NULL.
inline fasttest::I32IncrNV* fasttest::I32IncrNV_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (98);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32IncrNV);
    return cond ? reinterpret_cast<fasttest::I32IncrNV*>(&hdr) : NULL;
}

// --- fasttest.I32IncrNV.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32IncrNV& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32IncrNV..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32IncrNV& parent) {
    return i32(const_cast<fasttest::I32IncrNV&>(parent).length);
}

// --- fasttest.I32IncrNV..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32IncrNV& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32IncrNV&>(row).length));
}

// --- fasttest.I32IncrNV..Init
// Set all fields to initial values.
inline void fasttest::I32IncrNV_Init(fasttest::I32IncrNV& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(98);
    parent.Value98 = i32(0);
}
inline fasttest::I32IncrNull::I32IncrNull() {
    fasttest::I32IncrNull_Init(*this);
}


// --- fasttest.I32IncrNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32IncrNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32IncrNull.
// If not successful, quietly return NULL.
inline fasttest::I32IncrNull* fasttest::I32IncrNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (100);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32IncrNull);
    return cond ? reinterpret_cast<fasttest::I32IncrNull*>(&hdr) : NULL;
}

// --- fasttest.I32IncrNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32IncrNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32IncrNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32IncrNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32IncrNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32IncrNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32IncrNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32IncrNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32IncrNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32IncrNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32IncrNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32IncrNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32IncrNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32IncrNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32IncrNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32IncrNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32IncrNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32IncrNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32IncrNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32IncrNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32IncrNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32IncrNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32IncrNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32IncrNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32IncrNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32IncrNull& parent, fasttest::I32IncrNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32IncrNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32IncrNull& parent, fasttest::I32IncrNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32IncrNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32IncrNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32IncrNull.Value100.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value100_PresentQ(fasttest::I32IncrNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32IncrNull.Value100.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value100_SetPresent(fasttest::I32IncrNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32IncrNull.Value100.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value100_Present_GetBit(fasttest::I32IncrNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32IncrNull.Value100.Set
inline void fasttest::Value100_Set(fasttest::I32IncrNull& parent, i32 rhs) {
    parent.Value100 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32IncrNull.pmask_bitcurs.Reset
inline void fasttest::I32IncrNull_pmask_bitcurs_Reset(I32IncrNull_pmask_bitcurs &curs, fasttest::I32IncrNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32IncrNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32IncrNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32IncrNull_pmask_bitcurs_ValidQ(I32IncrNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32IncrNull.pmask_bitcurs.Access
// item access
inline int& fasttest::I32IncrNull_pmask_bitcurs_Access(I32IncrNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32IncrNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32IncrNull& parent) {
    return i32(const_cast<fasttest::I32IncrNull&>(parent).length);
}

// --- fasttest.I32IncrNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32IncrNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32IncrNull&>(row).length));
}

// --- fasttest.I32IncrNull..Init
// Set all fields to initial values.
inline void fasttest::I32IncrNull_Init(fasttest::I32IncrNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(100);
    parent.pmask = u32(0);
    parent.Value100 = i32(0);
}
inline fasttest::I32IncrOpt::I32IncrOpt() {
    fasttest::I32IncrOpt_Init(*this);
}


// --- fasttest.I32IncrOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32IncrOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32IncrOpt.
// If not successful, quietly return NULL.
inline fasttest::I32IncrOpt* fasttest::I32IncrOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (99);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32IncrOpt);
    return cond ? reinterpret_cast<fasttest::I32IncrOpt*>(&hdr) : NULL;
}

// --- fasttest.I32IncrOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32IncrOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32IncrOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32IncrOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32IncrOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32IncrOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32IncrOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32IncrOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32IncrOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32IncrOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32IncrOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32IncrOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32IncrOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32IncrOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32IncrOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32IncrOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32IncrOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32IncrOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32IncrOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32IncrOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32IncrOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32IncrOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32IncrOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32IncrOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32IncrOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32IncrOpt& parent, fasttest::I32IncrOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32IncrOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32IncrOpt& parent, fasttest::I32IncrOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32IncrOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32IncrOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32IncrOpt.Value99.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value99_PresentQ(fasttest::I32IncrOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32IncrOpt.Value99.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value99_SetPresent(fasttest::I32IncrOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32IncrOpt.Value99.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value99_Present_GetBit(fasttest::I32IncrOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32IncrOpt.Value99.Set
inline void fasttest::Value99_Set(fasttest::I32IncrOpt& parent, i32 rhs) {
    parent.Value99 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32IncrOpt.pmask_bitcurs.Reset
inline void fasttest::I32IncrOpt_pmask_bitcurs_Reset(I32IncrOpt_pmask_bitcurs &curs, fasttest::I32IncrOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32IncrOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32IncrOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32IncrOpt_pmask_bitcurs_ValidQ(I32IncrOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32IncrOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32IncrOpt_pmask_bitcurs_Access(I32IncrOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32IncrOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32IncrOpt& parent) {
    return i32(const_cast<fasttest::I32IncrOpt&>(parent).length);
}

// --- fasttest.I32IncrOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32IncrOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32IncrOpt&>(row).length));
}

// --- fasttest.I32IncrOpt..Init
// Set all fields to initial values.
inline void fasttest::I32IncrOpt_Init(fasttest::I32IncrOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(99);
    parent.pmask = u32(0);
    parent.Value99 = i32(99);
}
inline fasttest::I32None::I32None() {
    fasttest::I32None_Init(*this);
}


// --- fasttest.I32None.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32None by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32None.
// If not successful, quietly return NULL.
inline fasttest::I32None* fasttest::I32None_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (1);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32None);
    return cond ? reinterpret_cast<fasttest::I32None*>(&hdr) : NULL;
}

// --- fasttest.I32None.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32None& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32None..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32None& parent) {
    return i32(const_cast<fasttest::I32None&>(parent).length);
}

// --- fasttest.I32None..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32None& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32None&>(row).length));
}

// --- fasttest.I32None..Init
// Set all fields to initial values.
inline void fasttest::I32None_Init(fasttest::I32None& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(1);
    parent.Value = i32(0);
}
inline fasttest::I32NoneOpt::I32NoneOpt() {
    fasttest::I32NoneOpt_Init(*this);
}


// --- fasttest.I32NoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of I32NoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of I32NoneOpt.
// If not successful, quietly return NULL.
inline fasttest::I32NoneOpt* fasttest::I32NoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (2);
    cond &= i32(hdr.length) >= ssizeof(fasttest::I32NoneOpt);
    return cond ? reinterpret_cast<fasttest::I32NoneOpt*>(&hdr) : NULL;
}

// --- fasttest.I32NoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::I32NoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.I32NoneOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::I32NoneOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.I32NoneOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::I32NoneOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.I32NoneOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::I32NoneOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.I32NoneOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.I32NoneOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.I32NoneOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::I32NoneOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.I32NoneOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::I32NoneOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.I32NoneOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.I32NoneOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.I32NoneOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.I32NoneOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::I32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.I32NoneOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::I32NoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.I32NoneOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::I32NoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.I32NoneOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::I32NoneOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.I32NoneOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::I32NoneOpt& parent, fasttest::I32NoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32NoneOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::I32NoneOpt& parent, fasttest::I32NoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.I32NoneOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::I32NoneOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.I32NoneOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::I32NoneOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.I32NoneOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::I32NoneOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32NoneOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::I32NoneOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.I32NoneOpt.Value.Set
inline void fasttest::Value_Set(fasttest::I32NoneOpt& parent, i32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.I32NoneOpt.pmask_bitcurs.Reset
inline void fasttest::I32NoneOpt_pmask_bitcurs_Reset(I32NoneOpt_pmask_bitcurs &curs, fasttest::I32NoneOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    I32NoneOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.I32NoneOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::I32NoneOpt_pmask_bitcurs_ValidQ(I32NoneOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.I32NoneOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::I32NoneOpt_pmask_bitcurs_Access(I32NoneOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.I32NoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::I32NoneOpt& parent) {
    return i32(const_cast<fasttest::I32NoneOpt&>(parent).length);
}

// --- fasttest.I32NoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::I32NoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::I32NoneOpt&>(row).length));
}

// --- fasttest.I32NoneOpt..Init
// Set all fields to initial values.
inline void fasttest::I32NoneOpt_Init(fasttest::I32NoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(2);
    parent.pmask = u32(0);
    parent.Value = i32(0);
}
inline fasttest::MsgPmap::MsgPmap() {
    fasttest::MsgPmap_Init(*this);
}


// --- fasttest.MsgPmap.base.Castdown
// Check if fasttest::TemplateHeader is an instance of MsgPmap by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of MsgPmap.
// If not successful, quietly return NULL.
inline fasttest::MsgPmap* fasttest::MsgPmap_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (151);
    cond &= i32(hdr.length) >= ssizeof(fasttest::MsgPmap);
    return cond ? reinterpret_cast<fasttest::MsgPmap*>(&hdr) : NULL;
}

// --- fasttest.MsgPmap.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::MsgPmap& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.MsgPmap.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::MsgPmap& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.MsgPmap.pmask.qFind
// Access value
inline u64& fasttest::pmask_qFind(fasttest::MsgPmap& parent, int) {
    return parent.pmask;
}

// --- fasttest.MsgPmap.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::MsgPmap& parent) {
    return pmask_N(parent) * 64;
}

// --- fasttest.MsgPmap.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.MsgPmap.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u64 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.MsgPmap.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::MsgPmap& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.MsgPmap.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::MsgPmap& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u64_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.MsgPmap.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u64(1) << shift); // clear bit
}

// --- fasttest.MsgPmap.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u64 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u64(1) << shift); // clear bit
    }
}

// --- fasttest.MsgPmap.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u64(1) << shift); // set bit
}

// --- fasttest.MsgPmap.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::MsgPmap& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u64 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u64(1) << shift); // set bit
    }
}

// --- fasttest.MsgPmap.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::MsgPmap& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u64(1) << shift)) | (u64(val) << shift); // insert new value
}

// --- fasttest.MsgPmap.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::MsgPmap& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 6;
    u64 shift = bit_idx & 63;
    u64 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u64(val) << shift); // Or in val into elem
}

// --- fasttest.MsgPmap.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::MsgPmap& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.MsgPmap.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::MsgPmap& parent, fasttest::MsgPmap &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.MsgPmap.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::MsgPmap& parent, fasttest::MsgPmap &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.MsgPmap.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::MsgPmap& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u64 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 64 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.MsgPmap.Value1.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value1_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.MsgPmap.Value1.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value1_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value1.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value1_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value1.Get
inline u32 fasttest::Value1_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value2.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value2_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 11);
}

// --- fasttest.MsgPmap.Value2.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value2_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 11); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value2.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value2_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 11;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value2.Get
inline u32 fasttest::Value2_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value3.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value3_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 22);
}

// --- fasttest.MsgPmap.Value3.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value3_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 22); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value3.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value3_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 22;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value3.Get
inline u32 fasttest::Value3_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value4.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value4_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 33);
}

// --- fasttest.MsgPmap.Value4.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value4_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 33); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value4.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value4_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 33;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value4.Get
inline u32 fasttest::Value4_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value5.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value5_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 44);
}

// --- fasttest.MsgPmap.Value5.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value5_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 44); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value5.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value5_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 44;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value5.Get
inline u32 fasttest::Value5_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value6.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value6_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 55);
}

// --- fasttest.MsgPmap.Value6.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value6_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 55); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value6.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value6_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 55;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value6.Get
inline u32 fasttest::Value6_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value7.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value7_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 60);
}

// --- fasttest.MsgPmap.Value7.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value7_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 60); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value7.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value7_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 60;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value7.Get
inline u32 fasttest::Value7_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value8.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value8_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 61);
}

// --- fasttest.MsgPmap.Value8.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value8_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 61); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value8.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value8_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 61;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value8.Get
inline u32 fasttest::Value8_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value9.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value9_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 62);
}

// --- fasttest.MsgPmap.Value9.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value9_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 62); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value9.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value9_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 62;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value9.Get
inline u32 fasttest::Value9_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value10.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value10_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 1);
}

// --- fasttest.MsgPmap.Value10.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value10_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 1); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value10.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value10_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 1;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value10.Get
inline u32 fasttest::Value10_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value11.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value11_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 2);
}

// --- fasttest.MsgPmap.Value11.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value11_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 2); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value11.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value11_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 2;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value11.Get
inline u32 fasttest::Value11_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value12.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value12_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 3);
}

// --- fasttest.MsgPmap.Value12.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value12_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 3); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value12.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value12_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 3;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value12.Get
inline u32 fasttest::Value12_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value13.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value13_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 4);
}

// --- fasttest.MsgPmap.Value13.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value13_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 4); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value13.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value13_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 4;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value13.Get
inline u32 fasttest::Value13_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value14.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value14_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 5);
}

// --- fasttest.MsgPmap.Value14.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value14_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 5); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value14.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value14_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 5;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value14.Get
inline u32 fasttest::Value14_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value15.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value15_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 6);
}

// --- fasttest.MsgPmap.Value15.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value15_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 6); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value15.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value15_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 6;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value15.Get
inline u32 fasttest::Value15_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value16.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value16_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 7);
}

// --- fasttest.MsgPmap.Value16.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value16_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 7); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value16.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value16_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 7;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value16.Get
inline u32 fasttest::Value16_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value17.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value17_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 8);
}

// --- fasttest.MsgPmap.Value17.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value17_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 8); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value17.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value17_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 8;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value17.Get
inline u32 fasttest::Value17_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value18.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value18_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 9);
}

// --- fasttest.MsgPmap.Value18.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value18_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 9); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value18.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value18_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 9;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value18.Get
inline u32 fasttest::Value18_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value19.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value19_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 10);
}

// --- fasttest.MsgPmap.Value19.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value19_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 10); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value19.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value19_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 10;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value19.Get
inline u32 fasttest::Value19_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value20.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value20_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 12);
}

// --- fasttest.MsgPmap.Value20.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value20_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 12); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value20.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value20_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 12;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value20.Get
inline u32 fasttest::Value20_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value21.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value21_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 13);
}

// --- fasttest.MsgPmap.Value21.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value21_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 13); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value21.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value21_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 13;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value21.Get
inline u32 fasttest::Value21_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value22.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value22_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 14);
}

// --- fasttest.MsgPmap.Value22.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value22_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 14); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value22.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value22_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 14;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value22.Get
inline u32 fasttest::Value22_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value23.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value23_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 15);
}

// --- fasttest.MsgPmap.Value23.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value23_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 15); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value23.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value23_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 15;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value23.Get
inline u32 fasttest::Value23_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value24.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value24_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 16);
}

// --- fasttest.MsgPmap.Value24.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value24_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 16); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value24.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value24_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 16;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value24.Get
inline u32 fasttest::Value24_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value25.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value25_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 17);
}

// --- fasttest.MsgPmap.Value25.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value25_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 17); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value25.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value25_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 17;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value25.Get
inline u32 fasttest::Value25_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value26.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value26_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 18);
}

// --- fasttest.MsgPmap.Value26.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value26_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 18); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value26.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value26_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 18;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value26.Get
inline u32 fasttest::Value26_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value27.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value27_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 19);
}

// --- fasttest.MsgPmap.Value27.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value27_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 19); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value27.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value27_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 19;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value27.Get
inline u32 fasttest::Value27_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value28.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value28_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 20);
}

// --- fasttest.MsgPmap.Value28.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value28_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 20); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value28.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value28_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 20;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value28.Get
inline u32 fasttest::Value28_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value29.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value29_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 21);
}

// --- fasttest.MsgPmap.Value29.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value29_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 21); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value29.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value29_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 21;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value29.Get
inline u32 fasttest::Value29_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value30.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value30_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 23);
}

// --- fasttest.MsgPmap.Value30.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value30_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 23); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value30.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value30_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 23;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value30.Get
inline u32 fasttest::Value30_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value31.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value31_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 24);
}

// --- fasttest.MsgPmap.Value31.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value31_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 24); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value31.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value31_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 24;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value31.Get
inline u32 fasttest::Value31_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value32.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value32_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 25);
}

// --- fasttest.MsgPmap.Value32.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value32_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 25); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value32.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value32_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 25;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value32.Get
inline u32 fasttest::Value32_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value33.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value33_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 26);
}

// --- fasttest.MsgPmap.Value33.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value33_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 26); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value33.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value33_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 26;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value33.Get
inline u32 fasttest::Value33_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value34.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value34_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 27);
}

// --- fasttest.MsgPmap.Value34.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value34_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 27); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value34.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value34_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 27;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value34.Get
inline u32 fasttest::Value34_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value35.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value35_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 28);
}

// --- fasttest.MsgPmap.Value35.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value35_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 28); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value35.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value35_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 28;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value35.Get
inline u32 fasttest::Value35_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value36.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value36_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 29);
}

// --- fasttest.MsgPmap.Value36.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value36_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 29); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value36.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value36_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 29;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value36.Get
inline u32 fasttest::Value36_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value37.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value37_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 30);
}

// --- fasttest.MsgPmap.Value37.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value37_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 30); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value37.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value37_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 30;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value37.Get
inline u32 fasttest::Value37_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value38.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value38_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 31);
}

// --- fasttest.MsgPmap.Value38.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value38_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 31); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value38.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value38_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 31;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value38.Get
inline u32 fasttest::Value38_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value39.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value39_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 32);
}

// --- fasttest.MsgPmap.Value39.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value39_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 32); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value39.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value39_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 32;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value39.Get
inline u32 fasttest::Value39_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value40.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value40_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 34);
}

// --- fasttest.MsgPmap.Value40.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value40_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 34); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value40.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value40_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 34;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value40.Get
inline u32 fasttest::Value40_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value41.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value41_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 35);
}

// --- fasttest.MsgPmap.Value41.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value41_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 35); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value41.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value41_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 35;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value41.Get
inline u32 fasttest::Value41_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value42.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value42_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 36);
}

// --- fasttest.MsgPmap.Value42.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value42_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 36); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value42.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value42_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 36;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value42.Get
inline u32 fasttest::Value42_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value43.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value43_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 37);
}

// --- fasttest.MsgPmap.Value43.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value43_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 37); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value43.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value43_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 37;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value43.Get
inline u32 fasttest::Value43_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value44.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value44_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 38);
}

// --- fasttest.MsgPmap.Value44.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value44_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 38); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value44.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value44_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 38;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value44.Get
inline u32 fasttest::Value44_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value45.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value45_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 39);
}

// --- fasttest.MsgPmap.Value45.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value45_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 39); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value45.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value45_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 39;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value45.Get
inline u32 fasttest::Value45_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value46.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value46_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 40);
}

// --- fasttest.MsgPmap.Value46.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value46_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 40); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value46.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value46_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 40;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value46.Get
inline u32 fasttest::Value46_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value47.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value47_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 41);
}

// --- fasttest.MsgPmap.Value47.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value47_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 41); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value47.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value47_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 41;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value47.Get
inline u32 fasttest::Value47_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value48.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value48_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 42);
}

// --- fasttest.MsgPmap.Value48.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value48_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 42); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value48.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value48_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 42;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value48.Get
inline u32 fasttest::Value48_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value49.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value49_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 43);
}

// --- fasttest.MsgPmap.Value49.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value49_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 43); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value49.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value49_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 43;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value49.Get
inline u32 fasttest::Value49_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value50.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value50_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 45);
}

// --- fasttest.MsgPmap.Value50.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value50_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 45); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value50.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value50_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 45;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value50.Get
inline u32 fasttest::Value50_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value51.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value51_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 46);
}

// --- fasttest.MsgPmap.Value51.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value51_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 46); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value51.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value51_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 46;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value51.Get
inline u32 fasttest::Value51_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value52.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value52_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 47);
}

// --- fasttest.MsgPmap.Value52.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value52_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 47); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value52.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value52_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 47;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value52.Get
inline u32 fasttest::Value52_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value53.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value53_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 48);
}

// --- fasttest.MsgPmap.Value53.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value53_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 48); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value53.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value53_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 48;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value53.Get
inline u32 fasttest::Value53_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value54.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value54_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 49);
}

// --- fasttest.MsgPmap.Value54.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value54_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 49); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value54.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value54_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 49;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value54.Get
inline u32 fasttest::Value54_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value55.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value55_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 50);
}

// --- fasttest.MsgPmap.Value55.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value55_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 50); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value55.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value55_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 50;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value55.Get
inline u32 fasttest::Value55_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value56.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value56_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 51);
}

// --- fasttest.MsgPmap.Value56.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value56_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 51); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value56.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value56_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 51;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value56.Get
inline u32 fasttest::Value56_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value57.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value57_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 52);
}

// --- fasttest.MsgPmap.Value57.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value57_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 52); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value57.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value57_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 52;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value57.Get
inline u32 fasttest::Value57_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value58.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value58_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 53);
}

// --- fasttest.MsgPmap.Value58.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value58_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 53); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value58.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value58_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 53;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value58.Get
inline u32 fasttest::Value58_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value59.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value59_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 54);
}

// --- fasttest.MsgPmap.Value59.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value59_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 54); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value59.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value59_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 54;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value59.Get
inline u32 fasttest::Value59_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value60.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value60_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 56);
}

// --- fasttest.MsgPmap.Value60.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value60_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 56); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value60.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value60_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 56;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value60.Get
inline u32 fasttest::Value60_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value61.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value61_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 57);
}

// --- fasttest.MsgPmap.Value61.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value61_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 57); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value61.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value61_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 57;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value61.Get
inline u32 fasttest::Value61_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value62.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value62_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 58);
}

// --- fasttest.MsgPmap.Value62.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value62_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 58); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value62.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value62_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 58;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value62.Get
inline u32 fasttest::Value62_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.Value63.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value63_PresentQ(fasttest::MsgPmap& parent) {
    return pmask_qGetBit(parent, 59);
}

// --- fasttest.MsgPmap.Value63.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value63_SetPresent(fasttest::MsgPmap& parent) {
    pmask_qSetBit(parent, 59); // mark presence in pmask
}

// --- fasttest.MsgPmap.Value63.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value63_Present_GetBit(fasttest::MsgPmap& parent) {
    int retval = 59;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.MsgPmap.Value63.Get
inline u32 fasttest::Value63_Get(fasttest::MsgPmap& parent) {
    (void)parent;
    return u32(1);
}

// --- fasttest.MsgPmap.pmask_bitcurs.Reset
inline void fasttest::MsgPmap_pmask_bitcurs_Reset(MsgPmap_pmask_bitcurs &curs, fasttest::MsgPmap &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    MsgPmap_pmask_bitcurs_Next(curs);
}

// --- fasttest.MsgPmap.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::MsgPmap_pmask_bitcurs_ValidQ(MsgPmap_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*64;
}

// --- fasttest.MsgPmap.pmask_bitcurs.Access
// item access
inline int& fasttest::MsgPmap_pmask_bitcurs_Access(MsgPmap_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.MsgPmap..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::MsgPmap& parent) {
    return i32(const_cast<fasttest::MsgPmap&>(parent).length);
}

// --- fasttest.MsgPmap..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::MsgPmap& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::MsgPmap&>(row).length));
}
inline fasttest::OptSgmSeq::OptSgmSeq() {
    fasttest::OptSgmSeq_Init(*this);
}


// --- fasttest.OptSgmSeq..Init
// Set all fields to initial values.
inline void fasttest::OptSgmSeq_Init(fasttest::OptSgmSeq& OptSgmSeq) {
    OptSgmSeq.Value = u32(1);
}
inline fasttest::OptTrvSeq::OptTrvSeq() {
    fasttest::OptTrvSeq_Init(*this);
}


// --- fasttest.OptTrvSeq..Init
// Set all fields to initial values.
inline void fasttest::OptTrvSeq_Init(fasttest::OptTrvSeq& OptTrvSeq) {
    OptTrvSeq.Value = u32(0);
}
inline fasttest::Reset::Reset() {
    fasttest::Reset_Init(*this);
}


// --- fasttest.Reset.base.Castdown
// Check if fasttest::TemplateHeader is an instance of Reset by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of Reset.
// If not successful, quietly return NULL.
inline fasttest::Reset* fasttest::Reset_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (120);
    cond &= i32(hdr.length) >= ssizeof(fasttest::Reset);
    return cond ? reinterpret_cast<fasttest::Reset*>(&hdr) : NULL;
}

// --- fasttest.Reset.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::Reset& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.Reset..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::Reset& parent) {
    return i32(const_cast<fasttest::Reset&>(parent).length);
}

// --- fasttest.Reset..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::Reset& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::Reset&>(row).length));
}

// --- fasttest.Reset..Init
// Set all fields to initial values.
inline void fasttest::Reset_Init(fasttest::Reset& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(120);
}
inline fasttest::SampleEnumConst::SampleEnumConst() {
    fasttest::SampleEnumConst_Init(*this);
}


// --- fasttest.SampleEnumConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleEnumConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleEnumConst.
// If not successful, quietly return NULL.
inline fasttest::SampleEnumConst* fasttest::SampleEnumConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (145);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleEnumConst);
    return cond ? reinterpret_cast<fasttest::SampleEnumConst*>(&hdr) : NULL;
}

// --- fasttest.SampleEnumConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleEnumConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleEnumConst.Value.Get
inline fasttest::SampleEnum fasttest::Value_Get(fasttest::SampleEnumConst& parent) {
    (void)parent;
    return fasttest::SampleEnum(1);
}

// --- fasttest.SampleEnumConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleEnumConst& parent) {
    return i32(const_cast<fasttest::SampleEnumConst&>(parent).length);
}

// --- fasttest.SampleEnumConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleEnumConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleEnumConst&>(row).length));
}

// --- fasttest.SampleEnumConst..Init
// Set all fields to initial values.
inline void fasttest::SampleEnumConst_Init(fasttest::SampleEnumConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(145);
}
inline fasttest::SampleEnumCopy::SampleEnumCopy() {
    fasttest::SampleEnumCopy_Init(*this);
}


// --- fasttest.SampleEnumCopy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleEnumCopy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleEnumCopy.
// If not successful, quietly return NULL.
inline fasttest::SampleEnumCopy* fasttest::SampleEnumCopy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (147);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleEnumCopy);
    return cond ? reinterpret_cast<fasttest::SampleEnumCopy*>(&hdr) : NULL;
}

// --- fasttest.SampleEnumCopy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleEnumCopy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleEnumCopy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleEnumCopy& parent) {
    return i32(const_cast<fasttest::SampleEnumCopy&>(parent).length);
}

// --- fasttest.SampleEnumCopy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleEnumCopy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleEnumCopy&>(row).length));
}

// --- fasttest.SampleEnumCopy..Init
// Set all fields to initial values.
inline void fasttest::SampleEnumCopy_Init(fasttest::SampleEnumCopy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(147);
    parent.Value147 = fasttest_SampleEnumEnum(0);
}
inline fasttest::SampleEnumDefault::SampleEnumDefault() {
    fasttest::SampleEnumDefault_Init(*this);
}


// --- fasttest.SampleEnumDefault.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleEnumDefault by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleEnumDefault.
// If not successful, quietly return NULL.
inline fasttest::SampleEnumDefault* fasttest::SampleEnumDefault_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (146);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleEnumDefault);
    return cond ? reinterpret_cast<fasttest::SampleEnumDefault*>(&hdr) : NULL;
}

// --- fasttest.SampleEnumDefault.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleEnumDefault& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleEnumDefault..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleEnumDefault& parent) {
    return i32(const_cast<fasttest::SampleEnumDefault&>(parent).length);
}

// --- fasttest.SampleEnumDefault..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleEnumDefault& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleEnumDefault&>(row).length));
}

// --- fasttest.SampleEnumDefault..Init
// Set all fields to initial values.
inline void fasttest::SampleEnumDefault_Init(fasttest::SampleEnumDefault& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(146);
    parent.Value = fasttest_SampleEnumEnum(2);
}
inline fasttest::SampleSetConst::SampleSetConst() {
    fasttest::SampleSetConst_Init(*this);
}


// --- fasttest.SampleSetConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleSetConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleSetConst.
// If not successful, quietly return NULL.
inline fasttest::SampleSetConst* fasttest::SampleSetConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (148);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleSetConst);
    return cond ? reinterpret_cast<fasttest::SampleSetConst*>(&hdr) : NULL;
}

// --- fasttest.SampleSetConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleSetConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleSetConst.Value.Get
inline fasttest::SampleSet fasttest::Value_Get(fasttest::SampleSetConst& parent) {
    (void)parent;
    return fasttest::SampleSet(6);
}

// --- fasttest.SampleSetConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleSetConst& parent) {
    return i32(const_cast<fasttest::SampleSetConst&>(parent).length);
}

// --- fasttest.SampleSetConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleSetConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleSetConst&>(row).length));
}

// --- fasttest.SampleSetConst..Init
// Set all fields to initial values.
inline void fasttest::SampleSetConst_Init(fasttest::SampleSetConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(148);
}
inline fasttest::SampleSetCopy::SampleSetCopy() {
    fasttest::SampleSetCopy_Init(*this);
}


// --- fasttest.SampleSetCopy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleSetCopy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleSetCopy.
// If not successful, quietly return NULL.
inline fasttest::SampleSetCopy* fasttest::SampleSetCopy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (150);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleSetCopy);
    return cond ? reinterpret_cast<fasttest::SampleSetCopy*>(&hdr) : NULL;
}

// --- fasttest.SampleSetCopy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleSetCopy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleSetCopy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleSetCopy& parent) {
    return i32(const_cast<fasttest::SampleSetCopy&>(parent).length);
}

// --- fasttest.SampleSetCopy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleSetCopy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleSetCopy&>(row).length));
}

// --- fasttest.SampleSetCopy..Init
// Set all fields to initial values.
inline void fasttest::SampleSetCopy_Init(fasttest::SampleSetCopy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(150);
    parent.Value150 = fasttest::SampleSet(2);
}
inline fasttest::SampleSetDefault::SampleSetDefault() {
    fasttest::SampleSetDefault_Init(*this);
}


// --- fasttest.SampleSetDefault.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SampleSetDefault by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SampleSetDefault.
// If not successful, quietly return NULL.
inline fasttest::SampleSetDefault* fasttest::SampleSetDefault_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (149);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SampleSetDefault);
    return cond ? reinterpret_cast<fasttest::SampleSetDefault*>(&hdr) : NULL;
}

// --- fasttest.SampleSetDefault.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SampleSetDefault& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SampleSetDefault..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SampleSetDefault& parent) {
    return i32(const_cast<fasttest::SampleSetDefault&>(parent).length);
}

// --- fasttest.SampleSetDefault..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SampleSetDefault& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SampleSetDefault&>(row).length));
}

// --- fasttest.SampleSetDefault..Init
// Set all fields to initial values.
inline void fasttest::SampleSetDefault_Init(fasttest::SampleSetDefault& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(149);
    parent.Value = fasttest::SampleSet(3);
}
inline fasttest::SclConst::SclConst() {
    fasttest::SclConst_Init(*this);
}


// --- fasttest.SclConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclConst.
// If not successful, quietly return NULL.
inline fasttest::SclConst* fasttest::SclConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (25);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclConst);
    return cond ? reinterpret_cast<fasttest::SclConst*>(&hdr) : NULL;
}

// --- fasttest.SclConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclConst.Value.Get
inline algo::Decimal fasttest::Value_Get(fasttest::SclConst& parent) {
    (void)parent;
    return algo::Decimal(algo::Decimal(-2,25));
}

// --- fasttest.SclConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclConst& parent) {
    return i32(const_cast<fasttest::SclConst&>(parent).length);
}

// --- fasttest.SclConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclConst&>(row).length));
}

// --- fasttest.SclConst..Init
// Set all fields to initial values.
inline void fasttest::SclConst_Init(fasttest::SclConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(25);
}
inline fasttest::SclConstOpt::SclConstOpt() {
    fasttest::SclConstOpt_Init(*this);
}


// --- fasttest.SclConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclConstOpt.
// If not successful, quietly return NULL.
inline fasttest::SclConstOpt* fasttest::SclConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (26);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclConstOpt);
    return cond ? reinterpret_cast<fasttest::SclConstOpt*>(&hdr) : NULL;
}

// --- fasttest.SclConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclConstOpt& parent, fasttest::SclConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclConstOpt& parent, fasttest::SclConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclConstOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::SclConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclConstOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::SclConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclConstOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::SclConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclConstOpt.Value.Get
inline algo::Decimal fasttest::Value_Get(fasttest::SclConstOpt& parent) {
    (void)parent;
    return algo::Decimal(algo::Decimal(2,26));
}

// --- fasttest.SclConstOpt.pmask_bitcurs.Reset
inline void fasttest::SclConstOpt_pmask_bitcurs_Reset(SclConstOpt_pmask_bitcurs &curs, fasttest::SclConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclConstOpt_pmask_bitcurs_ValidQ(SclConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SclConstOpt_pmask_bitcurs_Access(SclConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclConstOpt& parent) {
    return i32(const_cast<fasttest::SclConstOpt&>(parent).length);
}

// --- fasttest.SclConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclConstOpt&>(row).length));
}

// --- fasttest.SclConstOpt..Init
// Set all fields to initial values.
inline void fasttest::SclConstOpt_Init(fasttest::SclConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(26);
    parent.pmask = u32(0);
}
inline fasttest::SclCopy::SclCopy() {
    fasttest::SclCopy_Init(*this);
}


// --- fasttest.SclCopy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclCopy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclCopy.
// If not successful, quietly return NULL.
inline fasttest::SclCopy* fasttest::SclCopy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (61);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclCopy);
    return cond ? reinterpret_cast<fasttest::SclCopy*>(&hdr) : NULL;
}

// --- fasttest.SclCopy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclCopy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclCopy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclCopy& parent) {
    return i32(const_cast<fasttest::SclCopy&>(parent).length);
}

// --- fasttest.SclCopy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclCopy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclCopy&>(row).length));
}

// --- fasttest.SclCopy..Init
// Set all fields to initial values.
inline void fasttest::SclCopy_Init(fasttest::SclCopy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(61);
    parent.Value61 = algo::Decimal(algo::Decimal(-2,-61));
}
inline fasttest::SclCopyNull::SclCopyNull() {
    fasttest::SclCopyNull_Init(*this);
}


// --- fasttest.SclCopyNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclCopyNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclCopyNull.
// If not successful, quietly return NULL.
inline fasttest::SclCopyNull* fasttest::SclCopyNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (63);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclCopyNull);
    return cond ? reinterpret_cast<fasttest::SclCopyNull*>(&hdr) : NULL;
}

// --- fasttest.SclCopyNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclCopyNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclCopyNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclCopyNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclCopyNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclCopyNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclCopyNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclCopyNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclCopyNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclCopyNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclCopyNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclCopyNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclCopyNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclCopyNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclCopyNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclCopyNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclCopyNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclCopyNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclCopyNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclCopyNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclCopyNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclCopyNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclCopyNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclCopyNull& parent, fasttest::SclCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclCopyNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclCopyNull& parent, fasttest::SclCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclCopyNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclCopyNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclCopyNull.Value63.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value63_PresentQ(fasttest::SclCopyNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclCopyNull.Value63.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value63_SetPresent(fasttest::SclCopyNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclCopyNull.Value63.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value63_Present_GetBit(fasttest::SclCopyNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclCopyNull.Value63.Set
inline void fasttest::Value63_Set(fasttest::SclCopyNull& parent, algo::Decimal rhs) {
    parent.Value63 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclCopyNull.pmask_bitcurs.Reset
inline void fasttest::SclCopyNull_pmask_bitcurs_Reset(SclCopyNull_pmask_bitcurs &curs, fasttest::SclCopyNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclCopyNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclCopyNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclCopyNull_pmask_bitcurs_ValidQ(SclCopyNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclCopyNull.pmask_bitcurs.Access
// item access
inline int& fasttest::SclCopyNull_pmask_bitcurs_Access(SclCopyNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclCopyNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclCopyNull& parent) {
    return i32(const_cast<fasttest::SclCopyNull&>(parent).length);
}

// --- fasttest.SclCopyNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclCopyNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclCopyNull&>(row).length));
}

// --- fasttest.SclCopyNull..Init
// Set all fields to initial values.
inline void fasttest::SclCopyNull_Init(fasttest::SclCopyNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(63);
    parent.pmask = u32(0);
    parent.Value63 = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SclCopyOpt::SclCopyOpt() {
    fasttest::SclCopyOpt_Init(*this);
}


// --- fasttest.SclCopyOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclCopyOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclCopyOpt.
// If not successful, quietly return NULL.
inline fasttest::SclCopyOpt* fasttest::SclCopyOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (62);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclCopyOpt);
    return cond ? reinterpret_cast<fasttest::SclCopyOpt*>(&hdr) : NULL;
}

// --- fasttest.SclCopyOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclCopyOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclCopyOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclCopyOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclCopyOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclCopyOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclCopyOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclCopyOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclCopyOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclCopyOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclCopyOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclCopyOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclCopyOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclCopyOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclCopyOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclCopyOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclCopyOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclCopyOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclCopyOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclCopyOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclCopyOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclCopyOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclCopyOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclCopyOpt& parent, fasttest::SclCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclCopyOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclCopyOpt& parent, fasttest::SclCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclCopyOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclCopyOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclCopyOpt.Value62.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value62_PresentQ(fasttest::SclCopyOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclCopyOpt.Value62.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value62_SetPresent(fasttest::SclCopyOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclCopyOpt.Value62.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value62_Present_GetBit(fasttest::SclCopyOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclCopyOpt.Value62.Set
inline void fasttest::Value62_Set(fasttest::SclCopyOpt& parent, algo::Decimal rhs) {
    parent.Value62 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclCopyOpt.pmask_bitcurs.Reset
inline void fasttest::SclCopyOpt_pmask_bitcurs_Reset(SclCopyOpt_pmask_bitcurs &curs, fasttest::SclCopyOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclCopyOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclCopyOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclCopyOpt_pmask_bitcurs_ValidQ(SclCopyOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclCopyOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SclCopyOpt_pmask_bitcurs_Access(SclCopyOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclCopyOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclCopyOpt& parent) {
    return i32(const_cast<fasttest::SclCopyOpt&>(parent).length);
}

// --- fasttest.SclCopyOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclCopyOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclCopyOpt&>(row).length));
}

// --- fasttest.SclCopyOpt..Init
// Set all fields to initial values.
inline void fasttest::SclCopyOpt_Init(fasttest::SclCopyOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(62);
    parent.pmask = u32(0);
    parent.Value62 = algo::Decimal(algo::Decimal(1,-62));
}
inline fasttest::SclDelta::SclDelta() {
    fasttest::SclDelta_Init(*this);
}


// --- fasttest.SclDelta.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDelta by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDelta.
// If not successful, quietly return NULL.
inline fasttest::SclDelta* fasttest::SclDelta_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (81);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDelta);
    return cond ? reinterpret_cast<fasttest::SclDelta*>(&hdr) : NULL;
}

// --- fasttest.SclDelta.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDelta& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDelta..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDelta& parent) {
    return i32(const_cast<fasttest::SclDelta&>(parent).length);
}

// --- fasttest.SclDelta..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDelta& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDelta&>(row).length));
}

// --- fasttest.SclDelta..Init
// Set all fields to initial values.
inline void fasttest::SclDelta_Init(fasttest::SclDelta& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(81);
    parent.Value81 = algo::Decimal(algo::Decimal(-2,-81));
}
inline fasttest::SclDeltaImpl::SclDeltaImpl() {
    fasttest::SclDeltaImpl_Init(*this);
}


// --- fasttest.SclDeltaImpl.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDeltaImpl by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDeltaImpl.
// If not successful, quietly return NULL.
inline fasttest::SclDeltaImpl* fasttest::SclDeltaImpl_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (82);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDeltaImpl);
    return cond ? reinterpret_cast<fasttest::SclDeltaImpl*>(&hdr) : NULL;
}

// --- fasttest.SclDeltaImpl.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDeltaImpl& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDeltaImpl..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDeltaImpl& parent) {
    return i32(const_cast<fasttest::SclDeltaImpl&>(parent).length);
}

// --- fasttest.SclDeltaImpl..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDeltaImpl& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDeltaImpl&>(row).length));
}

// --- fasttest.SclDeltaImpl..Init
// Set all fields to initial values.
inline void fasttest::SclDeltaImpl_Init(fasttest::SclDeltaImpl& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(82);
    parent.Value82 = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SclDeltaNull::SclDeltaNull() {
    fasttest::SclDeltaNull_Init(*this);
}


// --- fasttest.SclDeltaNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDeltaNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDeltaNull.
// If not successful, quietly return NULL.
inline fasttest::SclDeltaNull* fasttest::SclDeltaNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (84);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDeltaNull);
    return cond ? reinterpret_cast<fasttest::SclDeltaNull*>(&hdr) : NULL;
}

// --- fasttest.SclDeltaNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDeltaNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDeltaNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclDeltaNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclDeltaNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclDeltaNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclDeltaNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclDeltaNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclDeltaNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclDeltaNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclDeltaNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclDeltaNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclDeltaNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclDeltaNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclDeltaNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclDeltaNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclDeltaNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclDeltaNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclDeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclDeltaNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclDeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclDeltaNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclDeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclDeltaNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclDeltaNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclDeltaNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclDeltaNull& parent, fasttest::SclDeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDeltaNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclDeltaNull& parent, fasttest::SclDeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDeltaNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclDeltaNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclDeltaNull.Value84.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value84_PresentQ(fasttest::SclDeltaNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclDeltaNull.Value84.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value84_SetPresent(fasttest::SclDeltaNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDeltaNull.Value84.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value84_Present_GetBit(fasttest::SclDeltaNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclDeltaNull.Value84.Set
inline void fasttest::Value84_Set(fasttest::SclDeltaNull& parent, algo::Decimal rhs) {
    parent.Value84 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDeltaNull.pmask_bitcurs.Reset
inline void fasttest::SclDeltaNull_pmask_bitcurs_Reset(SclDeltaNull_pmask_bitcurs &curs, fasttest::SclDeltaNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclDeltaNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclDeltaNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclDeltaNull_pmask_bitcurs_ValidQ(SclDeltaNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclDeltaNull.pmask_bitcurs.Access
// item access
inline int& fasttest::SclDeltaNull_pmask_bitcurs_Access(SclDeltaNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclDeltaNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDeltaNull& parent) {
    return i32(const_cast<fasttest::SclDeltaNull&>(parent).length);
}

// --- fasttest.SclDeltaNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDeltaNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDeltaNull&>(row).length));
}

// --- fasttest.SclDeltaNull..Init
// Set all fields to initial values.
inline void fasttest::SclDeltaNull_Init(fasttest::SclDeltaNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(84);
    parent.pmask = u32(0);
    parent.Value84 = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SclDeltaOpt::SclDeltaOpt() {
    fasttest::SclDeltaOpt_Init(*this);
}


// --- fasttest.SclDeltaOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDeltaOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDeltaOpt.
// If not successful, quietly return NULL.
inline fasttest::SclDeltaOpt* fasttest::SclDeltaOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (83);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDeltaOpt);
    return cond ? reinterpret_cast<fasttest::SclDeltaOpt*>(&hdr) : NULL;
}

// --- fasttest.SclDeltaOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDeltaOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDeltaOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclDeltaOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclDeltaOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclDeltaOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclDeltaOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclDeltaOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclDeltaOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclDeltaOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclDeltaOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclDeltaOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclDeltaOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclDeltaOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclDeltaOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclDeltaOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclDeltaOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclDeltaOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclDeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclDeltaOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclDeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclDeltaOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclDeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclDeltaOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclDeltaOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclDeltaOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclDeltaOpt& parent, fasttest::SclDeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDeltaOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclDeltaOpt& parent, fasttest::SclDeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDeltaOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclDeltaOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclDeltaOpt.Value83.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value83_PresentQ(fasttest::SclDeltaOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclDeltaOpt.Value83.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value83_SetPresent(fasttest::SclDeltaOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDeltaOpt.Value83.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value83_Present_GetBit(fasttest::SclDeltaOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclDeltaOpt.Value83.Set
inline void fasttest::Value83_Set(fasttest::SclDeltaOpt& parent, algo::Decimal rhs) {
    parent.Value83 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDeltaOpt.pmask_bitcurs.Reset
inline void fasttest::SclDeltaOpt_pmask_bitcurs_Reset(SclDeltaOpt_pmask_bitcurs &curs, fasttest::SclDeltaOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclDeltaOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclDeltaOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclDeltaOpt_pmask_bitcurs_ValidQ(SclDeltaOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclDeltaOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SclDeltaOpt_pmask_bitcurs_Access(SclDeltaOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclDeltaOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDeltaOpt& parent) {
    return i32(const_cast<fasttest::SclDeltaOpt&>(parent).length);
}

// --- fasttest.SclDeltaOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDeltaOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDeltaOpt&>(row).length));
}

// --- fasttest.SclDeltaOpt..Init
// Set all fields to initial values.
inline void fasttest::SclDeltaOpt_Init(fasttest::SclDeltaOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(83);
    parent.pmask = u32(0);
    parent.Value83 = algo::Decimal(algo::Decimal(1,-83));
}
inline fasttest::SclDflt::SclDflt() {
    fasttest::SclDflt_Init(*this);
}


// --- fasttest.SclDflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDflt.
// If not successful, quietly return NULL.
inline fasttest::SclDflt* fasttest::SclDflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (45);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDflt);
    return cond ? reinterpret_cast<fasttest::SclDflt*>(&hdr) : NULL;
}

// --- fasttest.SclDflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDflt& parent) {
    return i32(const_cast<fasttest::SclDflt&>(parent).length);
}

// --- fasttest.SclDflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDflt&>(row).length));
}

// --- fasttest.SclDflt..Init
// Set all fields to initial values.
inline void fasttest::SclDflt_Init(fasttest::SclDflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(45);
    parent.Value = algo::Decimal(algo::Decimal(-2,-45));
}
inline fasttest::SclDfltNull::SclDfltNull() {
    fasttest::SclDfltNull_Init(*this);
}


// --- fasttest.SclDfltNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDfltNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDfltNull.
// If not successful, quietly return NULL.
inline fasttest::SclDfltNull* fasttest::SclDfltNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (47);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDfltNull);
    return cond ? reinterpret_cast<fasttest::SclDfltNull*>(&hdr) : NULL;
}

// --- fasttest.SclDfltNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDfltNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDfltNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclDfltNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclDfltNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclDfltNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclDfltNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclDfltNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclDfltNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclDfltNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclDfltNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclDfltNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclDfltNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclDfltNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclDfltNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclDfltNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclDfltNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclDfltNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclDfltNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclDfltNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclDfltNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclDfltNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclDfltNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclDfltNull& parent, fasttest::SclDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDfltNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclDfltNull& parent, fasttest::SclDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDfltNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclDfltNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclDfltNull.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::SclDfltNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclDfltNull.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::SclDfltNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDfltNull.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::SclDfltNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclDfltNull.Value.Set
inline void fasttest::Value_Set(fasttest::SclDfltNull& parent, algo::Decimal rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDfltNull.pmask_bitcurs.Reset
inline void fasttest::SclDfltNull_pmask_bitcurs_Reset(SclDfltNull_pmask_bitcurs &curs, fasttest::SclDfltNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclDfltNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclDfltNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclDfltNull_pmask_bitcurs_ValidQ(SclDfltNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclDfltNull.pmask_bitcurs.Access
// item access
inline int& fasttest::SclDfltNull_pmask_bitcurs_Access(SclDfltNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclDfltNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDfltNull& parent) {
    return i32(const_cast<fasttest::SclDfltNull&>(parent).length);
}

// --- fasttest.SclDfltNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDfltNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDfltNull&>(row).length));
}

// --- fasttest.SclDfltNull..Init
// Set all fields to initial values.
inline void fasttest::SclDfltNull_Init(fasttest::SclDfltNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(47);
    parent.pmask = u32(0);
    parent.Value = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SclDfltOpt::SclDfltOpt() {
    fasttest::SclDfltOpt_Init(*this);
}


// --- fasttest.SclDfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclDfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclDfltOpt.
// If not successful, quietly return NULL.
inline fasttest::SclDfltOpt* fasttest::SclDfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (46);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclDfltOpt);
    return cond ? reinterpret_cast<fasttest::SclDfltOpt*>(&hdr) : NULL;
}

// --- fasttest.SclDfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclDfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclDfltOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclDfltOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclDfltOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclDfltOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclDfltOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclDfltOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclDfltOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclDfltOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclDfltOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclDfltOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclDfltOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclDfltOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclDfltOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclDfltOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclDfltOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclDfltOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclDfltOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclDfltOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclDfltOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclDfltOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclDfltOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclDfltOpt& parent, fasttest::SclDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDfltOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclDfltOpt& parent, fasttest::SclDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclDfltOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclDfltOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclDfltOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::SclDfltOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclDfltOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::SclDfltOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDfltOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::SclDfltOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclDfltOpt.Value.Set
inline void fasttest::Value_Set(fasttest::SclDfltOpt& parent, algo::Decimal rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclDfltOpt.pmask_bitcurs.Reset
inline void fasttest::SclDfltOpt_pmask_bitcurs_Reset(SclDfltOpt_pmask_bitcurs &curs, fasttest::SclDfltOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclDfltOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclDfltOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclDfltOpt_pmask_bitcurs_ValidQ(SclDfltOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclDfltOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SclDfltOpt_pmask_bitcurs_Access(SclDfltOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclDfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclDfltOpt& parent) {
    return i32(const_cast<fasttest::SclDfltOpt&>(parent).length);
}

// --- fasttest.SclDfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclDfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclDfltOpt&>(row).length));
}

// --- fasttest.SclDfltOpt..Init
// Set all fields to initial values.
inline void fasttest::SclDfltOpt_Init(fasttest::SclDfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(46);
    parent.pmask = u32(0);
    parent.Value = algo::Decimal(algo::Decimal(1,-46));
}
inline fasttest::SclNone::SclNone() {
    fasttest::SclNone_Init(*this);
}


// --- fasttest.SclNone.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclNone by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclNone.
// If not successful, quietly return NULL.
inline fasttest::SclNone* fasttest::SclNone_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (9);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclNone);
    return cond ? reinterpret_cast<fasttest::SclNone*>(&hdr) : NULL;
}

// --- fasttest.SclNone.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclNone& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclNone..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclNone& parent) {
    return i32(const_cast<fasttest::SclNone&>(parent).length);
}

// --- fasttest.SclNone..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclNone& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclNone&>(row).length));
}

// --- fasttest.SclNone..Init
// Set all fields to initial values.
inline void fasttest::SclNone_Init(fasttest::SclNone& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(9);
    parent.Value = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SclNoneOpt::SclNoneOpt() {
    fasttest::SclNoneOpt_Init(*this);
}


// --- fasttest.SclNoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SclNoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SclNoneOpt.
// If not successful, quietly return NULL.
inline fasttest::SclNoneOpt* fasttest::SclNoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (10);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SclNoneOpt);
    return cond ? reinterpret_cast<fasttest::SclNoneOpt*>(&hdr) : NULL;
}

// --- fasttest.SclNoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SclNoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SclNoneOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SclNoneOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SclNoneOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SclNoneOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SclNoneOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SclNoneOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SclNoneOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SclNoneOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SclNoneOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SclNoneOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SclNoneOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SclNoneOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SclNoneOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SclNoneOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SclNoneOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SclNoneOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SclNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SclNoneOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SclNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SclNoneOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SclNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SclNoneOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SclNoneOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SclNoneOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SclNoneOpt& parent, fasttest::SclNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclNoneOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SclNoneOpt& parent, fasttest::SclNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SclNoneOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SclNoneOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SclNoneOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::SclNoneOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SclNoneOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::SclNoneOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclNoneOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::SclNoneOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SclNoneOpt.Value.Set
inline void fasttest::Value_Set(fasttest::SclNoneOpt& parent, algo::Decimal rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SclNoneOpt.pmask_bitcurs.Reset
inline void fasttest::SclNoneOpt_pmask_bitcurs_Reset(SclNoneOpt_pmask_bitcurs &curs, fasttest::SclNoneOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SclNoneOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SclNoneOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SclNoneOpt_pmask_bitcurs_ValidQ(SclNoneOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SclNoneOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SclNoneOpt_pmask_bitcurs_Access(SclNoneOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SclNoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SclNoneOpt& parent) {
    return i32(const_cast<fasttest::SclNoneOpt&>(parent).length);
}

// --- fasttest.SclNoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SclNoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SclNoneOpt&>(row).length));
}

// --- fasttest.SclNoneOpt..Init
// Set all fields to initial values.
inline void fasttest::SclNoneOpt_Init(fasttest::SclNoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(10);
    parent.pmask = u32(0);
    parent.Value = algo::Decimal(algo::Decimal(0,0));
}
inline fasttest::SecondSeq::SecondSeq() {
    fasttest::SecondSeq_Init(*this);
}


// --- fasttest.SecondSeq..Init
// Set all fields to initial values.
inline void fasttest::SecondSeq_Init(fasttest::SecondSeq& parent) {
    parent.Value2 = u32(0);
}
inline fasttest::SeqOrder::SeqOrder() {
    fasttest::SeqOrder_Init(*this);
}


// --- fasttest.SeqOrder.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqOrder by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqOrder.
// If not successful, quietly return NULL.
inline fasttest::SeqOrder* fasttest::SeqOrder_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (135);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqOrder);
    return cond ? reinterpret_cast<fasttest::SeqOrder*>(&hdr) : NULL;
}

// --- fasttest.SeqOrder.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqOrder& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqOrder.FirstSeq.N
// Return number of elements in varlen field
inline u32 fasttest::FirstSeq_N(const fasttest::SeqOrder& parent) {
    u32 length = i32(((fasttest::SeqOrder&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqOrder)) - sizeof(fasttest::SeqOrder); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::FirstSeq));
}

// --- fasttest.SeqOrder.FirstSeq_curs.Reset
inline void fasttest::SeqOrder_FirstSeq_curs_Reset(SeqOrder_FirstSeq_curs &curs, fasttest::SeqOrder &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqOrder);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqOrder);
    curs.index = 0;
}

// --- fasttest.SeqOrder.FirstSeq_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqOrder_FirstSeq_curs_ValidQ(SeqOrder_FirstSeq_curs &curs) {
    bool valid = ssizeof(fasttest::FirstSeq) <= curs.length;
    return valid;
}

// --- fasttest.SeqOrder.FirstSeq_curs.Next
// proceed to next item
inline void fasttest::SeqOrder_FirstSeq_curs_Next(SeqOrder_FirstSeq_curs &curs) {
    i32 len = i32(sizeof(fasttest::FirstSeq));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqOrder.FirstSeq_curs.Access
// item access
inline fasttest::FirstSeq& fasttest::SeqOrder_FirstSeq_curs_Access(SeqOrder_FirstSeq_curs &curs) {
    return *(fasttest::FirstSeq*)curs.ptr;
}

// --- fasttest.SeqOrder..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqOrder& parent) {
    return i32(const_cast<fasttest::SeqOrder&>(parent).length);
}

// --- fasttest.SeqOrder..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqOrder& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqOrder&>(row).length));
}

// --- fasttest.SeqOrder..Init
// Set all fields to initial values.
inline void fasttest::SeqOrder_Init(fasttest::SeqOrder& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(135);
    parent.Value3 = u32(0);
}
inline fasttest::SeqSgmOpt::SeqSgmOpt() {
    fasttest::SeqSgmOpt_Init(*this);
}


// --- fasttest.SeqSgmOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqSgmOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqSgmOpt.
// If not successful, quietly return NULL.
inline fasttest::SeqSgmOpt* fasttest::SeqSgmOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (118);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqSgmOpt);
    return cond ? reinterpret_cast<fasttest::SeqSgmOpt*>(&hdr) : NULL;
}

// --- fasttest.SeqSgmOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqSgmOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqSgmOpt.OptSgmSeq.N
// Return number of elements in varlen field
inline u32 fasttest::OptSgmSeq_N(const fasttest::SeqSgmOpt& parent) {
    u32 length = i32(((fasttest::SeqSgmOpt&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqSgmOpt)) - sizeof(fasttest::SeqSgmOpt); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::OptSgmSeq));
}

// --- fasttest.SeqSgmOpt.OptSgmSeq_curs.Reset
inline void fasttest::SeqSgmOpt_OptSgmSeq_curs_Reset(SeqSgmOpt_OptSgmSeq_curs &curs, fasttest::SeqSgmOpt &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqSgmOpt);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqSgmOpt);
    curs.index = 0;
}

// --- fasttest.SeqSgmOpt.OptSgmSeq_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqSgmOpt_OptSgmSeq_curs_ValidQ(SeqSgmOpt_OptSgmSeq_curs &curs) {
    bool valid = ssizeof(fasttest::OptSgmSeq) <= curs.length;
    return valid;
}

// --- fasttest.SeqSgmOpt.OptSgmSeq_curs.Next
// proceed to next item
inline void fasttest::SeqSgmOpt_OptSgmSeq_curs_Next(SeqSgmOpt_OptSgmSeq_curs &curs) {
    i32 len = i32(sizeof(fasttest::OptSgmSeq));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqSgmOpt.OptSgmSeq_curs.Access
// item access
inline fasttest::OptSgmSeq& fasttest::SeqSgmOpt_OptSgmSeq_curs_Access(SeqSgmOpt_OptSgmSeq_curs &curs) {
    return *(fasttest::OptSgmSeq*)curs.ptr;
}

// --- fasttest.SeqSgmOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqSgmOpt& parent) {
    return i32(const_cast<fasttest::SeqSgmOpt&>(parent).length);
}

// --- fasttest.SeqSgmOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqSgmOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqSgmOpt&>(row).length));
}

// --- fasttest.SeqSgmOpt..Init
// Set all fields to initial values.
inline void fasttest::SeqSgmOpt_Init(fasttest::SeqSgmOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(118);
}
inline fasttest::TrvSeq::TrvSeq() {
    fasttest::TrvSeq_Init(*this);
}


// --- fasttest.TrvSeq..Init
// Set all fields to initial values.
inline void fasttest::TrvSeq_Init(fasttest::TrvSeq& TrvSeq) {
    TrvSeq.Value = u32(0);
}
inline fasttest::SeqTrv::SeqTrv() {
    fasttest::SeqTrv_Init(*this);
}


// --- fasttest.SeqTrv.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrv by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrv.
// If not successful, quietly return NULL.
inline fasttest::SeqTrv* fasttest::SeqTrv_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (116);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrv);
    return cond ? reinterpret_cast<fasttest::SeqTrv*>(&hdr) : NULL;
}

// --- fasttest.SeqTrv.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrv& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrv.TrvSeq.N
// Return number of elements in varlen field
inline u32 fasttest::TrvSeq_N(const fasttest::SeqTrv& parent) {
    u32 length = i32(((fasttest::SeqTrv&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrv)) - sizeof(fasttest::SeqTrv); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::TrvSeq));
}

// --- fasttest.SeqTrv.TrvSeq_curs.Reset
inline void fasttest::SeqTrv_TrvSeq_curs_Reset(SeqTrv_TrvSeq_curs &curs, fasttest::SeqTrv &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrv);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrv);
    curs.index = 0;
}

// --- fasttest.SeqTrv.TrvSeq_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrv_TrvSeq_curs_ValidQ(SeqTrv_TrvSeq_curs &curs) {
    bool valid = ssizeof(fasttest::TrvSeq) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrv.TrvSeq_curs.Next
// proceed to next item
inline void fasttest::SeqTrv_TrvSeq_curs_Next(SeqTrv_TrvSeq_curs &curs) {
    i32 len = i32(sizeof(fasttest::TrvSeq));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrv.TrvSeq_curs.Access
// item access
inline fasttest::TrvSeq& fasttest::SeqTrv_TrvSeq_curs_Access(SeqTrv_TrvSeq_curs &curs) {
    return *(fasttest::TrvSeq*)curs.ptr;
}

// --- fasttest.SeqTrv..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrv& parent) {
    return i32(const_cast<fasttest::SeqTrv&>(parent).length);
}

// --- fasttest.SeqTrv..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrv& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrv&>(row).length));
}

// --- fasttest.SeqTrv..Init
// Set all fields to initial values.
inline void fasttest::SeqTrv_Init(fasttest::SeqTrv& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(116);
}
inline fasttest::TrvSeqLenConst::TrvSeqLenConst() {
    fasttest::TrvSeqLenConst_Init(*this);
}


// --- fasttest.TrvSeqLenConst..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqLenConst_Init(fasttest::TrvSeqLenConst& parent) {
    parent.Value = u32(0);
}
inline fasttest::SeqTrvLenConst::SeqTrvLenConst() {
    fasttest::SeqTrvLenConst_Init(*this);
}


// --- fasttest.SeqTrvLenConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenConst.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenConst* fasttest::SeqTrvLenConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (131);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenConst);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenConst*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenConst& parent) {
    return i32(const_cast<fasttest::SeqTrvLenConst&>(parent).length);
}

// --- fasttest.SeqTrvLenConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenConst&>(row).length));
}

// --- fasttest.SeqTrvLenConst..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenConst_Init(fasttest::SeqTrvLenConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(131);
}
inline fasttest::TrvSeqLenConstOpt::TrvSeqLenConstOpt() {
    fasttest::TrvSeqLenConstOpt_Init(*this);
}


// --- fasttest.TrvSeqLenConstOpt..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqLenConstOpt_Init(fasttest::TrvSeqLenConstOpt& parent) {
    parent.Value = u32(0);
}
inline fasttest::SeqTrvLenConstOpt::SeqTrvLenConstOpt() {
    fasttest::SeqTrvLenConstOpt_Init(*this);
}


// --- fasttest.SeqTrvLenConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenConstOpt.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenConstOpt* fasttest::SeqTrvLenConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (132);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenConstOpt);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenConstOpt*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::SeqTrvLenConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::SeqTrvLenConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::SeqTrvLenConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.SeqTrvLenConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::SeqTrvLenConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::SeqTrvLenConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.SeqTrvLenConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.SeqTrvLenConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.SeqTrvLenConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::SeqTrvLenConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.SeqTrvLenConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::SeqTrvLenConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.SeqTrvLenConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::SeqTrvLenConstOpt& parent, fasttest::SeqTrvLenConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.SeqTrvLenConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::SeqTrvLenConstOpt& parent, fasttest::SeqTrvLenConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.SeqTrvLenConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::SeqTrvLenConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::TrvSeqLenConstOpt_PresentQ(fasttest::SeqTrvLenConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::TrvSeqLenConstOpt_SetPresent(fasttest::SeqTrvLenConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::TrvSeqLenConstOpt_Present_GetBit(fasttest::SeqTrvLenConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.Set
inline void fasttest::TrvSeqLenConstOpt_Set(fasttest::SeqTrvLenConstOpt& parent, const fasttest::TrvSeqLenConstOpt& rhs) {
    parent.TrvSeqLenConstOpt = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.SeqTrvLenConstOpt.pmask_bitcurs.Reset
inline void fasttest::SeqTrvLenConstOpt_pmask_bitcurs_Reset(SeqTrvLenConstOpt_pmask_bitcurs &curs, fasttest::SeqTrvLenConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    SeqTrvLenConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.SeqTrvLenConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvLenConstOpt_pmask_bitcurs_ValidQ(SeqTrvLenConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.SeqTrvLenConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::SeqTrvLenConstOpt_pmask_bitcurs_Access(SeqTrvLenConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.SeqTrvLenConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenConstOpt& parent) {
    return i32(const_cast<fasttest::SeqTrvLenConstOpt&>(parent).length);
}

// --- fasttest.SeqTrvLenConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenConstOpt&>(row).length));
}

// --- fasttest.SeqTrvLenConstOpt..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenConstOpt_Init(fasttest::SeqTrvLenConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(132);
    parent.pmask = u32(0);
}
inline fasttest::TrvSeqLenDflt::TrvSeqLenDflt() {
    fasttest::TrvSeqLenDflt_Init(*this);
}


// --- fasttest.TrvSeqLenDflt..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqLenDflt_Init(fasttest::TrvSeqLenDflt& TrvSeqLenDflt) {
    TrvSeqLenDflt.Value = u32(0);
}
inline fasttest::SeqTrvLenDflt::SeqTrvLenDflt() {
    fasttest::SeqTrvLenDflt_Init(*this);
}


// --- fasttest.SeqTrvLenDflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenDflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenDflt.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenDflt* fasttest::SeqTrvLenDflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (133);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenDflt);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenDflt*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenDflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenDflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.N
// Return number of elements in varlen field
inline u32 fasttest::TrvSeqLenDflt_N(const fasttest::SeqTrvLenDflt& parent) {
    u32 length = i32(((fasttest::SeqTrvLenDflt&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrvLenDflt)) - sizeof(fasttest::SeqTrvLenDflt); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::TrvSeqLenDflt));
}

// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt_curs.Reset
inline void fasttest::SeqTrvLenDflt_TrvSeqLenDflt_curs_Reset(SeqTrvLenDflt_TrvSeqLenDflt_curs &curs, fasttest::SeqTrvLenDflt &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrvLenDflt);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrvLenDflt);
    curs.index = 0;
}

// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvLenDflt_TrvSeqLenDflt_curs_ValidQ(SeqTrvLenDflt_TrvSeqLenDflt_curs &curs) {
    bool valid = ssizeof(fasttest::TrvSeqLenDflt) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt_curs.Next
// proceed to next item
inline void fasttest::SeqTrvLenDflt_TrvSeqLenDflt_curs_Next(SeqTrvLenDflt_TrvSeqLenDflt_curs &curs) {
    i32 len = i32(sizeof(fasttest::TrvSeqLenDflt));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt_curs.Access
// item access
inline fasttest::TrvSeqLenDflt& fasttest::SeqTrvLenDflt_TrvSeqLenDflt_curs_Access(SeqTrvLenDflt_TrvSeqLenDflt_curs &curs) {
    return *(fasttest::TrvSeqLenDflt*)curs.ptr;
}

// --- fasttest.SeqTrvLenDflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenDflt& parent) {
    return i32(const_cast<fasttest::SeqTrvLenDflt&>(parent).length);
}

// --- fasttest.SeqTrvLenDflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenDflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenDflt&>(row).length));
}

// --- fasttest.SeqTrvLenDflt..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenDflt_Init(fasttest::SeqTrvLenDflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(133);
}
inline fasttest::TrvSeqDfltOpt::TrvSeqDfltOpt() {
    fasttest::TrvSeqDfltOpt_Init(*this);
}


// --- fasttest.TrvSeqDfltOpt..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqDfltOpt_Init(fasttest::TrvSeqDfltOpt& TrvSeqDfltOpt) {
    TrvSeqDfltOpt.Value = u32(0);
}
inline fasttest::SeqTrvLenDfltOpt::SeqTrvLenDfltOpt() {
    fasttest::SeqTrvLenDfltOpt_Init(*this);
}


// --- fasttest.SeqTrvLenDfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenDfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenDfltOpt.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenDfltOpt* fasttest::SeqTrvLenDfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (134);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenDfltOpt);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenDfltOpt*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenDfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenDfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.N
// Return number of elements in varlen field
inline u32 fasttest::TrvSeqDfltOpt_N(const fasttest::SeqTrvLenDfltOpt& parent) {
    u32 length = i32(((fasttest::SeqTrvLenDfltOpt&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrvLenDfltOpt)) - sizeof(fasttest::SeqTrvLenDfltOpt); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::TrvSeqDfltOpt));
}

// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt_curs.Reset
inline void fasttest::SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs_Reset(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs &curs, fasttest::SeqTrvLenDfltOpt &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrvLenDfltOpt);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrvLenDfltOpt);
    curs.index = 0;
}

// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs_ValidQ(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs &curs) {
    bool valid = ssizeof(fasttest::TrvSeqDfltOpt) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt_curs.Next
// proceed to next item
inline void fasttest::SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs_Next(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs &curs) {
    i32 len = i32(sizeof(fasttest::TrvSeqDfltOpt));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt_curs.Access
// item access
inline fasttest::TrvSeqDfltOpt& fasttest::SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs_Access(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs &curs) {
    return *(fasttest::TrvSeqDfltOpt*)curs.ptr;
}

// --- fasttest.SeqTrvLenDfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenDfltOpt& parent) {
    return i32(const_cast<fasttest::SeqTrvLenDfltOpt&>(parent).length);
}

// --- fasttest.SeqTrvLenDfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenDfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenDfltOpt&>(row).length));
}

// --- fasttest.SeqTrvLenDfltOpt..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenDfltOpt_Init(fasttest::SeqTrvLenDfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(134);
}
inline fasttest::TrvSeqLenNone::TrvSeqLenNone() {
    fasttest::TrvSeqLenNone_Init(*this);
}


// --- fasttest.TrvSeqLenNone..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqLenNone_Init(fasttest::TrvSeqLenNone& TrvSeqLenNone) {
    TrvSeqLenNone.Value = u32(0);
}
inline fasttest::SeqTrvLenNone::SeqTrvLenNone() {
    fasttest::SeqTrvLenNone_Init(*this);
}


// --- fasttest.SeqTrvLenNone.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenNone by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenNone.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenNone* fasttest::SeqTrvLenNone_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (129);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenNone);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenNone*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenNone.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenNone& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.N
// Return number of elements in varlen field
inline u32 fasttest::TrvSeqLenNone_N(const fasttest::SeqTrvLenNone& parent) {
    u32 length = i32(((fasttest::SeqTrvLenNone&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrvLenNone)) - sizeof(fasttest::SeqTrvLenNone); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::TrvSeqLenNone));
}

// --- fasttest.SeqTrvLenNone.TrvSeqLenNone_curs.Reset
inline void fasttest::SeqTrvLenNone_TrvSeqLenNone_curs_Reset(SeqTrvLenNone_TrvSeqLenNone_curs &curs, fasttest::SeqTrvLenNone &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrvLenNone);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrvLenNone);
    curs.index = 0;
}

// --- fasttest.SeqTrvLenNone.TrvSeqLenNone_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvLenNone_TrvSeqLenNone_curs_ValidQ(SeqTrvLenNone_TrvSeqLenNone_curs &curs) {
    bool valid = ssizeof(fasttest::TrvSeqLenNone) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrvLenNone.TrvSeqLenNone_curs.Next
// proceed to next item
inline void fasttest::SeqTrvLenNone_TrvSeqLenNone_curs_Next(SeqTrvLenNone_TrvSeqLenNone_curs &curs) {
    i32 len = i32(sizeof(fasttest::TrvSeqLenNone));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrvLenNone.TrvSeqLenNone_curs.Access
// item access
inline fasttest::TrvSeqLenNone& fasttest::SeqTrvLenNone_TrvSeqLenNone_curs_Access(SeqTrvLenNone_TrvSeqLenNone_curs &curs) {
    return *(fasttest::TrvSeqLenNone*)curs.ptr;
}

// --- fasttest.SeqTrvLenNone..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenNone& parent) {
    return i32(const_cast<fasttest::SeqTrvLenNone&>(parent).length);
}

// --- fasttest.SeqTrvLenNone..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenNone& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenNone&>(row).length));
}

// --- fasttest.SeqTrvLenNone..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenNone_Init(fasttest::SeqTrvLenNone& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(129);
}
inline fasttest::TrvSeqLenNoneOpt::TrvSeqLenNoneOpt() {
    fasttest::TrvSeqLenNoneOpt_Init(*this);
}


// --- fasttest.TrvSeqLenNoneOpt..Init
// Set all fields to initial values.
inline void fasttest::TrvSeqLenNoneOpt_Init(fasttest::TrvSeqLenNoneOpt& TrvSeqLenNoneOpt) {
    TrvSeqLenNoneOpt.Value = u32(0);
}
inline fasttest::SeqTrvLenNoneOpt::SeqTrvLenNoneOpt() {
    fasttest::SeqTrvLenNoneOpt_Init(*this);
}


// --- fasttest.SeqTrvLenNoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvLenNoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvLenNoneOpt.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvLenNoneOpt* fasttest::SeqTrvLenNoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (130);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvLenNoneOpt);
    return cond ? reinterpret_cast<fasttest::SeqTrvLenNoneOpt*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvLenNoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvLenNoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.N
// Return number of elements in varlen field
inline u32 fasttest::TrvSeqLenNoneOpt_N(const fasttest::SeqTrvLenNoneOpt& parent) {
    u32 length = i32(((fasttest::SeqTrvLenNoneOpt&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrvLenNoneOpt)) - sizeof(fasttest::SeqTrvLenNoneOpt); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::TrvSeqLenNoneOpt));
}

// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt_curs.Reset
inline void fasttest::SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs_Reset(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs &curs, fasttest::SeqTrvLenNoneOpt &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrvLenNoneOpt);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrvLenNoneOpt);
    curs.index = 0;
}

// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs_ValidQ(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs &curs) {
    bool valid = ssizeof(fasttest::TrvSeqLenNoneOpt) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt_curs.Next
// proceed to next item
inline void fasttest::SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs_Next(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs &curs) {
    i32 len = i32(sizeof(fasttest::TrvSeqLenNoneOpt));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt_curs.Access
// item access
inline fasttest::TrvSeqLenNoneOpt& fasttest::SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs_Access(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs &curs) {
    return *(fasttest::TrvSeqLenNoneOpt*)curs.ptr;
}

// --- fasttest.SeqTrvLenNoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvLenNoneOpt& parent) {
    return i32(const_cast<fasttest::SeqTrvLenNoneOpt&>(parent).length);
}

// --- fasttest.SeqTrvLenNoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvLenNoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvLenNoneOpt&>(row).length));
}

// --- fasttest.SeqTrvLenNoneOpt..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvLenNoneOpt_Init(fasttest::SeqTrvLenNoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(130);
}
inline fasttest::SeqTrvOpt::SeqTrvOpt() {
    fasttest::SeqTrvOpt_Init(*this);
}


// --- fasttest.SeqTrvOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of SeqTrvOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of SeqTrvOpt.
// If not successful, quietly return NULL.
inline fasttest::SeqTrvOpt* fasttest::SeqTrvOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (117);
    cond &= i32(hdr.length) >= ssizeof(fasttest::SeqTrvOpt);
    return cond ? reinterpret_cast<fasttest::SeqTrvOpt*>(&hdr) : NULL;
}

// --- fasttest.SeqTrvOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::SeqTrvOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.SeqTrvOpt.OptTrvSeq.N
// Return number of elements in varlen field
inline u32 fasttest::OptTrvSeq_N(const fasttest::SeqTrvOpt& parent) {
    u32 length = i32(((fasttest::SeqTrvOpt&)parent).length);
    u32 extra_bytes = u32_Max(length,sizeof(fasttest::SeqTrvOpt)) - sizeof(fasttest::SeqTrvOpt); // avoid unsigned subtraction underflow
    return u32(extra_bytes / sizeof(fasttest::OptTrvSeq));
}

// --- fasttest.SeqTrvOpt.OptTrvSeq_curs.Reset
inline void fasttest::SeqTrvOpt_OptTrvSeq_curs_Reset(SeqTrvOpt_OptTrvSeq_curs &curs, fasttest::SeqTrvOpt &parent) {
    curs.ptr = (u8*)&parent + sizeof(fasttest::SeqTrvOpt);
    curs.length = i32(parent.length) - sizeof(fasttest::SeqTrvOpt);
    curs.index = 0;
}

// --- fasttest.SeqTrvOpt.OptTrvSeq_curs.ValidQ
// cursor points to valid item
inline bool fasttest::SeqTrvOpt_OptTrvSeq_curs_ValidQ(SeqTrvOpt_OptTrvSeq_curs &curs) {
    bool valid = ssizeof(fasttest::OptTrvSeq) <= curs.length;
    return valid;
}

// --- fasttest.SeqTrvOpt.OptTrvSeq_curs.Next
// proceed to next item
inline void fasttest::SeqTrvOpt_OptTrvSeq_curs_Next(SeqTrvOpt_OptTrvSeq_curs &curs) {
    i32 len = i32(sizeof(fasttest::OptTrvSeq));
    curs.ptr += len;
    curs.length -= len;
    ++curs.index;
}

// --- fasttest.SeqTrvOpt.OptTrvSeq_curs.Access
// item access
inline fasttest::OptTrvSeq& fasttest::SeqTrvOpt_OptTrvSeq_curs_Access(SeqTrvOpt_OptTrvSeq_curs &curs) {
    return *(fasttest::OptTrvSeq*)curs.ptr;
}

// --- fasttest.SeqTrvOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::SeqTrvOpt& parent) {
    return i32(const_cast<fasttest::SeqTrvOpt&>(parent).length);
}

// --- fasttest.SeqTrvOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::SeqTrvOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::SeqTrvOpt&>(row).length));
}

// --- fasttest.SeqTrvOpt..Init
// Set all fields to initial values.
inline void fasttest::SeqTrvOpt_Init(fasttest::SeqTrvOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(117);
}
inline fasttest::StrConst::StrConst() {
    fasttest::StrConst_Init(*this);
}


// --- fasttest.StrConst.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrConst by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrConst.
// If not successful, quietly return NULL.
inline fasttest::StrConst* fasttest::StrConst_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (21);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrConst);
    return cond ? reinterpret_cast<fasttest::StrConst*>(&hdr) : NULL;
}

// --- fasttest.StrConst.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrConst& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrConst.Value.Get
inline algo::strptr fasttest::Value_Get(fasttest::StrConst& parent) {
    (void)parent;
    return algo::strptr("A21");
}

// --- fasttest.StrConst..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrConst& parent) {
    return i32(const_cast<fasttest::StrConst&>(parent).length);
}

// --- fasttest.StrConst..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrConst& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrConst&>(row).length));
}

// --- fasttest.StrConst..Init
// Set all fields to initial values.
inline void fasttest::StrConst_Init(fasttest::StrConst& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(21);
}
inline fasttest::StrConstOpt::StrConstOpt() {
    fasttest::StrConstOpt_Init(*this);
}


// --- fasttest.StrConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrConstOpt.
// If not successful, quietly return NULL.
inline fasttest::StrConstOpt* fasttest::StrConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (22);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrConstOpt);
    return cond ? reinterpret_cast<fasttest::StrConstOpt*>(&hdr) : NULL;
}

// --- fasttest.StrConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrConstOpt& parent, fasttest::StrConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrConstOpt& parent, fasttest::StrConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrConstOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::StrConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrConstOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::StrConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrConstOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::StrConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrConstOpt.Value.Get
inline algo::strptr fasttest::Value_Get(fasttest::StrConstOpt& parent) {
    (void)parent;
    return algo::strptr("A22");
}

// --- fasttest.StrConstOpt.pmask_bitcurs.Reset
inline void fasttest::StrConstOpt_pmask_bitcurs_Reset(StrConstOpt_pmask_bitcurs &curs, fasttest::StrConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrConstOpt_pmask_bitcurs_ValidQ(StrConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::StrConstOpt_pmask_bitcurs_Access(StrConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrConstOpt& parent) {
    return i32(const_cast<fasttest::StrConstOpt&>(parent).length);
}

// --- fasttest.StrConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrConstOpt&>(row).length));
}

// --- fasttest.StrConstOpt..Init
// Set all fields to initial values.
inline void fasttest::StrConstOpt_Init(fasttest::StrConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(22);
    parent.pmask = u32(0);
}
inline fasttest::StrCopy::StrCopy() {
    fasttest::StrCopy_Init(*this);
}


// --- fasttest.StrCopy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrCopy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrCopy.
// If not successful, quietly return NULL.
inline fasttest::StrCopy* fasttest::StrCopy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (55);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrCopy);
    return cond ? reinterpret_cast<fasttest::StrCopy*>(&hdr) : NULL;
}

// --- fasttest.StrCopy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrCopy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrCopy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrCopy& parent) {
    return i32(const_cast<fasttest::StrCopy&>(parent).length);
}

// --- fasttest.StrCopy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrCopy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrCopy&>(row).length));
}

// --- fasttest.StrCopy..Init
// Set all fields to initial values.
inline void fasttest::StrCopy_Init(fasttest::StrCopy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(55);
    parent.Value55 = algo::strptr("A55");
}
inline fasttest::StrCopyNull::StrCopyNull() {
    fasttest::StrCopyNull_Init(*this);
}


// --- fasttest.StrCopyNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrCopyNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrCopyNull.
// If not successful, quietly return NULL.
inline fasttest::StrCopyNull* fasttest::StrCopyNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (57);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrCopyNull);
    return cond ? reinterpret_cast<fasttest::StrCopyNull*>(&hdr) : NULL;
}

// --- fasttest.StrCopyNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrCopyNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrCopyNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrCopyNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrCopyNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrCopyNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrCopyNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrCopyNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrCopyNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrCopyNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrCopyNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrCopyNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrCopyNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrCopyNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrCopyNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrCopyNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrCopyNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrCopyNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrCopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrCopyNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrCopyNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrCopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrCopyNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrCopyNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrCopyNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrCopyNull& parent, fasttest::StrCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrCopyNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrCopyNull& parent, fasttest::StrCopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrCopyNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrCopyNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrCopyNull.Value57.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value57_PresentQ(fasttest::StrCopyNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrCopyNull.Value57.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value57_SetPresent(fasttest::StrCopyNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrCopyNull.Value57.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value57_Present_GetBit(fasttest::StrCopyNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrCopyNull.Value57.Set
inline void fasttest::Value57_Set(fasttest::StrCopyNull& parent, const algo::strptr& rhs) {
    parent.Value57 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrCopyNull.pmask_bitcurs.Reset
inline void fasttest::StrCopyNull_pmask_bitcurs_Reset(StrCopyNull_pmask_bitcurs &curs, fasttest::StrCopyNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrCopyNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrCopyNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrCopyNull_pmask_bitcurs_ValidQ(StrCopyNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrCopyNull.pmask_bitcurs.Access
// item access
inline int& fasttest::StrCopyNull_pmask_bitcurs_Access(StrCopyNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrCopyNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrCopyNull& parent) {
    return i32(const_cast<fasttest::StrCopyNull&>(parent).length);
}

// --- fasttest.StrCopyNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrCopyNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrCopyNull&>(row).length));
}

// --- fasttest.StrCopyNull..Init
// Set all fields to initial values.
inline void fasttest::StrCopyNull_Init(fasttest::StrCopyNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(57);
    parent.pmask = u32(0);
}
inline fasttest::StrCopyOpt::StrCopyOpt() {
    fasttest::StrCopyOpt_Init(*this);
}


// --- fasttest.StrCopyOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrCopyOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrCopyOpt.
// If not successful, quietly return NULL.
inline fasttest::StrCopyOpt* fasttest::StrCopyOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (56);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrCopyOpt);
    return cond ? reinterpret_cast<fasttest::StrCopyOpt*>(&hdr) : NULL;
}

// --- fasttest.StrCopyOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrCopyOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrCopyOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrCopyOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrCopyOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrCopyOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrCopyOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrCopyOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrCopyOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrCopyOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrCopyOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrCopyOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrCopyOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrCopyOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrCopyOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrCopyOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrCopyOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrCopyOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrCopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrCopyOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrCopyOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrCopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrCopyOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrCopyOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrCopyOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrCopyOpt& parent, fasttest::StrCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrCopyOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrCopyOpt& parent, fasttest::StrCopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrCopyOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrCopyOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrCopyOpt.Value56.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value56_PresentQ(fasttest::StrCopyOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrCopyOpt.Value56.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value56_SetPresent(fasttest::StrCopyOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrCopyOpt.Value56.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value56_Present_GetBit(fasttest::StrCopyOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrCopyOpt.Value56.Set
inline void fasttest::Value56_Set(fasttest::StrCopyOpt& parent, const algo::strptr& rhs) {
    parent.Value56 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrCopyOpt.pmask_bitcurs.Reset
inline void fasttest::StrCopyOpt_pmask_bitcurs_Reset(StrCopyOpt_pmask_bitcurs &curs, fasttest::StrCopyOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrCopyOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrCopyOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrCopyOpt_pmask_bitcurs_ValidQ(StrCopyOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrCopyOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::StrCopyOpt_pmask_bitcurs_Access(StrCopyOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrCopyOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrCopyOpt& parent) {
    return i32(const_cast<fasttest::StrCopyOpt&>(parent).length);
}

// --- fasttest.StrCopyOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrCopyOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrCopyOpt&>(row).length));
}

// --- fasttest.StrCopyOpt..Init
// Set all fields to initial values.
inline void fasttest::StrCopyOpt_Init(fasttest::StrCopyOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(56);
    parent.pmask = u32(0);
    parent.Value56 = algo::strptr("A56");
}
inline fasttest::StrDflt::StrDflt() {
    fasttest::StrDflt_Init(*this);
}


// --- fasttest.StrDflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrDflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrDflt.
// If not successful, quietly return NULL.
inline fasttest::StrDflt* fasttest::StrDflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (39);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrDflt);
    return cond ? reinterpret_cast<fasttest::StrDflt*>(&hdr) : NULL;
}

// --- fasttest.StrDflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrDflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrDflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrDflt& parent) {
    return i32(const_cast<fasttest::StrDflt&>(parent).length);
}

// --- fasttest.StrDflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrDflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrDflt&>(row).length));
}

// --- fasttest.StrDflt..Init
// Set all fields to initial values.
inline void fasttest::StrDflt_Init(fasttest::StrDflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(39);
    parent.Value = algo::strptr("A39");
}
inline fasttest::StrDfltNull::StrDfltNull() {
    fasttest::StrDfltNull_Init(*this);
}


// --- fasttest.StrDfltNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrDfltNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrDfltNull.
// If not successful, quietly return NULL.
inline fasttest::StrDfltNull* fasttest::StrDfltNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (41);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrDfltNull);
    return cond ? reinterpret_cast<fasttest::StrDfltNull*>(&hdr) : NULL;
}

// --- fasttest.StrDfltNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrDfltNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrDfltNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrDfltNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrDfltNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrDfltNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrDfltNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrDfltNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrDfltNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrDfltNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrDfltNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrDfltNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrDfltNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrDfltNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrDfltNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrDfltNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrDfltNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrDfltNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrDfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrDfltNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrDfltNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrDfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrDfltNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrDfltNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrDfltNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrDfltNull& parent, fasttest::StrDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrDfltNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrDfltNull& parent, fasttest::StrDfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrDfltNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrDfltNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrDfltNull.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::StrDfltNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrDfltNull.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::StrDfltNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrDfltNull.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::StrDfltNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrDfltNull.Value.Set
inline void fasttest::Value_Set(fasttest::StrDfltNull& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrDfltNull.pmask_bitcurs.Reset
inline void fasttest::StrDfltNull_pmask_bitcurs_Reset(StrDfltNull_pmask_bitcurs &curs, fasttest::StrDfltNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrDfltNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrDfltNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrDfltNull_pmask_bitcurs_ValidQ(StrDfltNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrDfltNull.pmask_bitcurs.Access
// item access
inline int& fasttest::StrDfltNull_pmask_bitcurs_Access(StrDfltNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrDfltNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrDfltNull& parent) {
    return i32(const_cast<fasttest::StrDfltNull&>(parent).length);
}

// --- fasttest.StrDfltNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrDfltNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrDfltNull&>(row).length));
}

// --- fasttest.StrDfltNull..Init
// Set all fields to initial values.
inline void fasttest::StrDfltNull_Init(fasttest::StrDfltNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(41);
    parent.pmask = u32(0);
}
inline fasttest::StrDfltOpt::StrDfltOpt() {
    fasttest::StrDfltOpt_Init(*this);
}


// --- fasttest.StrDfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrDfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrDfltOpt.
// If not successful, quietly return NULL.
inline fasttest::StrDfltOpt* fasttest::StrDfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (40);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrDfltOpt);
    return cond ? reinterpret_cast<fasttest::StrDfltOpt*>(&hdr) : NULL;
}

// --- fasttest.StrDfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrDfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrDfltOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrDfltOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrDfltOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrDfltOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrDfltOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrDfltOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrDfltOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrDfltOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrDfltOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrDfltOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrDfltOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrDfltOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrDfltOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrDfltOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrDfltOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrDfltOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrDfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrDfltOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrDfltOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrDfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrDfltOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrDfltOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrDfltOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrDfltOpt& parent, fasttest::StrDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrDfltOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrDfltOpt& parent, fasttest::StrDfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrDfltOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrDfltOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrDfltOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::StrDfltOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrDfltOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::StrDfltOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrDfltOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::StrDfltOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrDfltOpt.Value.Set
inline void fasttest::Value_Set(fasttest::StrDfltOpt& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrDfltOpt.pmask_bitcurs.Reset
inline void fasttest::StrDfltOpt_pmask_bitcurs_Reset(StrDfltOpt_pmask_bitcurs &curs, fasttest::StrDfltOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrDfltOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrDfltOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrDfltOpt_pmask_bitcurs_ValidQ(StrDfltOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrDfltOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::StrDfltOpt_pmask_bitcurs_Access(StrDfltOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrDfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrDfltOpt& parent) {
    return i32(const_cast<fasttest::StrDfltOpt&>(parent).length);
}

// --- fasttest.StrDfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrDfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrDfltOpt&>(row).length));
}

// --- fasttest.StrDfltOpt..Init
// Set all fields to initial values.
inline void fasttest::StrDfltOpt_Init(fasttest::StrDfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(40);
    parent.pmask = u32(0);
    parent.Value = algo::strptr("A40");
}
inline fasttest::StrNone::StrNone() {
    fasttest::StrNone_Init(*this);
}


// --- fasttest.StrNone.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrNone by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrNone.
// If not successful, quietly return NULL.
inline fasttest::StrNone* fasttest::StrNone_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (5);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrNone);
    return cond ? reinterpret_cast<fasttest::StrNone*>(&hdr) : NULL;
}

// --- fasttest.StrNone.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrNone& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrNone..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrNone& parent) {
    return i32(const_cast<fasttest::StrNone&>(parent).length);
}

// --- fasttest.StrNone..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrNone& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrNone&>(row).length));
}

// --- fasttest.StrNone..Init
// Set all fields to initial values.
inline void fasttest::StrNone_Init(fasttest::StrNone& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(5);
}
inline fasttest::StrNoneOpt::StrNoneOpt() {
    fasttest::StrNoneOpt_Init(*this);
}


// --- fasttest.StrNoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of StrNoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of StrNoneOpt.
// If not successful, quietly return NULL.
inline fasttest::StrNoneOpt* fasttest::StrNoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (6);
    cond &= i32(hdr.length) >= ssizeof(fasttest::StrNoneOpt);
    return cond ? reinterpret_cast<fasttest::StrNoneOpt*>(&hdr) : NULL;
}

// --- fasttest.StrNoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::StrNoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.StrNoneOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::StrNoneOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.StrNoneOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::StrNoneOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.StrNoneOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::StrNoneOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.StrNoneOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.StrNoneOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.StrNoneOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::StrNoneOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.StrNoneOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::StrNoneOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.StrNoneOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.StrNoneOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.StrNoneOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.StrNoneOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::StrNoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.StrNoneOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::StrNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.StrNoneOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::StrNoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.StrNoneOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::StrNoneOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.StrNoneOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::StrNoneOpt& parent, fasttest::StrNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrNoneOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::StrNoneOpt& parent, fasttest::StrNoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.StrNoneOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::StrNoneOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.StrNoneOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::StrNoneOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.StrNoneOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::StrNoneOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrNoneOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::StrNoneOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.StrNoneOpt.Value.Set
inline void fasttest::Value_Set(fasttest::StrNoneOpt& parent, const algo::strptr& rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.StrNoneOpt.pmask_bitcurs.Reset
inline void fasttest::StrNoneOpt_pmask_bitcurs_Reset(StrNoneOpt_pmask_bitcurs &curs, fasttest::StrNoneOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    StrNoneOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.StrNoneOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::StrNoneOpt_pmask_bitcurs_ValidQ(StrNoneOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.StrNoneOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::StrNoneOpt_pmask_bitcurs_Access(StrNoneOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.StrNoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::StrNoneOpt& parent) {
    return i32(const_cast<fasttest::StrNoneOpt&>(parent).length);
}

// --- fasttest.StrNoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::StrNoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::StrNoneOpt&>(row).length));
}

// --- fasttest.StrNoneOpt..Init
// Set all fields to initial values.
inline void fasttest::StrNoneOpt_Init(fasttest::StrNoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(6);
    parent.pmask = u32(0);
}
inline fasttest::TemplateHeader::TemplateHeader() {
    fasttest::TemplateHeader_Init(*this);
}


// --- fasttest.TemplateHeader.id.GetEnum
// Get value of field as enum type
inline fasttest_TemplateHeader_id_Enum fasttest::id_GetEnum(const fasttest::TemplateHeader& parent) {
    return fasttest_TemplateHeader_id_Enum(parent.id);
}

// --- fasttest.TemplateHeader.id.SetEnum
// Set value of field from enum type.
inline void fasttest::id_SetEnum(fasttest::TemplateHeader& parent, fasttest_TemplateHeader_id_Enum rhs) {
    parent.id = u32(rhs);
}

// --- fasttest.TemplateHeader..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::TemplateHeader& parent) {
    return i32(const_cast<fasttest::TemplateHeader&>(parent).length);
}

// --- fasttest.TemplateHeader..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::TemplateHeader& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::TemplateHeader&>(row).length));
}

// --- fasttest.TemplateHeader..Init
// Set all fields to initial values.
inline void fasttest::TemplateHeader_Init(fasttest::TemplateHeader& parent) {
    parent.length = u32(0);
    parent.id = u32(0);
}
inline fasttest::TemplateHeaderMsgsCase::TemplateHeaderMsgsCase(u32                            in_value)
    : value(in_value)
{
}
inline fasttest::TemplateHeaderMsgsCase::TemplateHeaderMsgsCase(fasttest_TemplateHeaderMsgsCaseEnum arg) { this->value = u32(arg); }
inline fasttest::TemplateHeaderMsgsCase::TemplateHeaderMsgsCase() {
    fasttest::TemplateHeaderMsgsCase_Init(*this);
}


// --- fasttest.TemplateHeaderMsgsCase.value.GetEnum
// Get value of field as enum type
inline fasttest_TemplateHeaderMsgsCaseEnum fasttest::value_GetEnum(const fasttest::TemplateHeaderMsgsCase& parent) {
    return fasttest_TemplateHeaderMsgsCaseEnum(parent.value);
}

// --- fasttest.TemplateHeaderMsgsCase.value.SetEnum
// Set value of field from enum type.
inline void fasttest::value_SetEnum(fasttest::TemplateHeaderMsgsCase& parent, fasttest_TemplateHeaderMsgsCaseEnum rhs) {
    parent.value = u32(rhs);
}

// --- fasttest.TemplateHeaderMsgsCase.value.Cast
inline fasttest::TemplateHeaderMsgsCase::operator fasttest_TemplateHeaderMsgsCaseEnum () const {
    return fasttest_TemplateHeaderMsgsCaseEnum((*this).value);
}

// --- fasttest.TemplateHeaderMsgsCase..Init
// Set all fields to initial values.
inline void fasttest::TemplateHeaderMsgsCase_Init(fasttest::TemplateHeaderMsgsCase& parent) {
    parent.value = u32(0);
}
inline fasttest::TemplateHeader_curs::TemplateHeader_curs() {
    fasttest::TemplateHeader_curs_Init(*this);
}


// --- fasttest.TemplateHeader_curs..ValidQ
inline bool fasttest::TemplateHeader_curs_ValidQ(fasttest::TemplateHeader_curs& curs) {
    return curs.msg != NULL;
}

// --- fasttest.TemplateHeader_curs..Reset
inline void fasttest::TemplateHeader_curs_Reset(fasttest::TemplateHeader_curs& curs, algo::memptr buf) {
    curs.bytes = buf.elems;
    curs.limit = buf.n_elems;
    fasttest::TemplateHeader *msg = NULL;
    int msglen = 0;
    if (curs.limit >= ssizeof(fasttest::TemplateHeader)) {
        fasttest::TemplateHeader *ptr = (fasttest::TemplateHeader*)curs.bytes;
        msglen = i32((*ptr).length);
        if (msglen >= ssizeof(fasttest::TemplateHeader) && curs.limit >= msglen) {
            msg = ptr;
        }
    }
    curs.msg = msg;
    curs.msglen = msglen;
}

// --- fasttest.TemplateHeader_curs..Access
inline fasttest::TemplateHeader*& fasttest::TemplateHeader_curs_Access(fasttest::TemplateHeader_curs& curs) {
    return curs.msg;
}

// --- fasttest.TemplateHeader_curs..Next
inline void fasttest::TemplateHeader_curs_Next(fasttest::TemplateHeader_curs& curs) {
    curs.bytes += curs.msglen;
    curs.limit -= curs.msglen;
    fasttest::TemplateHeader *msg = NULL;
    int msglen = 0;
    if (curs.limit >= ssizeof(fasttest::TemplateHeader)) {
        fasttest::TemplateHeader *ptr = (fasttest::TemplateHeader*)curs.bytes;
        msglen = i32((*ptr).length);
        if (msglen >= ssizeof(fasttest::TemplateHeader) && curs.limit >= msglen) {
            msg = ptr;
        }
    }
    curs.msg = msg;
    curs.msglen = msglen;
}

// --- fasttest.TemplateHeader_curs..Init
// Set all fields to initial values.
inline void fasttest::TemplateHeader_curs_Init(fasttest::TemplateHeader_curs& parent) {
    parent.msg = NULL;
    parent.bytes = NULL;
    parent.limit = i32(0);
    parent.msglen = i32(0);
}
inline fasttest::U32Const::U32Const() {
    fasttest::U32Const_Init(*this);
}


// --- fasttest.U32Const.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32Const by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32Const.
// If not successful, quietly return NULL.
inline fasttest::U32Const* fasttest::U32Const_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (19);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32Const);
    return cond ? reinterpret_cast<fasttest::U32Const*>(&hdr) : NULL;
}

// --- fasttest.U32Const.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32Const& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32Const.Value.Get
inline u32 fasttest::Value_Get(fasttest::U32Const& parent) {
    (void)parent;
    return u32(19);
}

// --- fasttest.U32Const..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32Const& parent) {
    return i32(const_cast<fasttest::U32Const&>(parent).length);
}

// --- fasttest.U32Const..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32Const& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32Const&>(row).length));
}

// --- fasttest.U32Const..Init
// Set all fields to initial values.
inline void fasttest::U32Const_Init(fasttest::U32Const& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(19);
}
inline fasttest::U32ConstOpt::U32ConstOpt() {
    fasttest::U32ConstOpt_Init(*this);
}


// --- fasttest.U32ConstOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32ConstOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32ConstOpt.
// If not successful, quietly return NULL.
inline fasttest::U32ConstOpt* fasttest::U32ConstOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (20);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32ConstOpt);
    return cond ? reinterpret_cast<fasttest::U32ConstOpt*>(&hdr) : NULL;
}

// --- fasttest.U32ConstOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32ConstOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32ConstOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32ConstOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32ConstOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32ConstOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32ConstOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32ConstOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32ConstOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32ConstOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32ConstOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32ConstOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32ConstOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32ConstOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32ConstOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32ConstOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32ConstOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32ConstOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32ConstOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32ConstOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32ConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32ConstOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32ConstOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32ConstOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32ConstOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32ConstOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32ConstOpt& parent, fasttest::U32ConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32ConstOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32ConstOpt& parent, fasttest::U32ConstOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32ConstOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32ConstOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32ConstOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::U32ConstOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32ConstOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::U32ConstOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32ConstOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::U32ConstOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32ConstOpt.Value.Get
inline u32 fasttest::Value_Get(fasttest::U32ConstOpt& parent) {
    (void)parent;
    return u32(20);
}

// --- fasttest.U32ConstOpt.pmask_bitcurs.Reset
inline void fasttest::U32ConstOpt_pmask_bitcurs_Reset(U32ConstOpt_pmask_bitcurs &curs, fasttest::U32ConstOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32ConstOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32ConstOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32ConstOpt_pmask_bitcurs_ValidQ(U32ConstOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32ConstOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32ConstOpt_pmask_bitcurs_Access(U32ConstOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32ConstOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32ConstOpt& parent) {
    return i32(const_cast<fasttest::U32ConstOpt&>(parent).length);
}

// --- fasttest.U32ConstOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32ConstOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32ConstOpt&>(row).length));
}

// --- fasttest.U32ConstOpt..Init
// Set all fields to initial values.
inline void fasttest::U32ConstOpt_Init(fasttest::U32ConstOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(20);
    parent.pmask = u32(0);
}
inline fasttest::U32Copy::U32Copy() {
    fasttest::U32Copy_Init(*this);
}


// --- fasttest.U32Copy.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32Copy by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32Copy.
// If not successful, quietly return NULL.
inline fasttest::U32Copy* fasttest::U32Copy_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (52);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32Copy);
    return cond ? reinterpret_cast<fasttest::U32Copy*>(&hdr) : NULL;
}

// --- fasttest.U32Copy.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32Copy& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32Copy..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32Copy& parent) {
    return i32(const_cast<fasttest::U32Copy&>(parent).length);
}

// --- fasttest.U32Copy..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32Copy& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32Copy&>(row).length));
}

// --- fasttest.U32Copy..Init
// Set all fields to initial values.
inline void fasttest::U32Copy_Init(fasttest::U32Copy& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(52);
    parent.Value52 = u32(52);
}
inline fasttest::U32CopyNull::U32CopyNull() {
    fasttest::U32CopyNull_Init(*this);
}


// --- fasttest.U32CopyNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32CopyNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32CopyNull.
// If not successful, quietly return NULL.
inline fasttest::U32CopyNull* fasttest::U32CopyNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (54);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32CopyNull);
    return cond ? reinterpret_cast<fasttest::U32CopyNull*>(&hdr) : NULL;
}

// --- fasttest.U32CopyNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32CopyNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32CopyNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32CopyNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32CopyNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32CopyNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32CopyNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32CopyNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32CopyNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32CopyNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32CopyNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32CopyNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32CopyNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32CopyNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32CopyNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32CopyNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32CopyNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32CopyNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32CopyNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32CopyNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32CopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32CopyNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32CopyNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32CopyNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32CopyNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32CopyNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32CopyNull& parent, fasttest::U32CopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32CopyNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32CopyNull& parent, fasttest::U32CopyNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32CopyNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32CopyNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32CopyNull.Value54.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value54_PresentQ(fasttest::U32CopyNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32CopyNull.Value54.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value54_SetPresent(fasttest::U32CopyNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32CopyNull.Value54.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value54_Present_GetBit(fasttest::U32CopyNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32CopyNull.Value54.Set
inline void fasttest::Value54_Set(fasttest::U32CopyNull& parent, u32 rhs) {
    parent.Value54 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32CopyNull.pmask_bitcurs.Reset
inline void fasttest::U32CopyNull_pmask_bitcurs_Reset(U32CopyNull_pmask_bitcurs &curs, fasttest::U32CopyNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32CopyNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32CopyNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32CopyNull_pmask_bitcurs_ValidQ(U32CopyNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32CopyNull.pmask_bitcurs.Access
// item access
inline int& fasttest::U32CopyNull_pmask_bitcurs_Access(U32CopyNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32CopyNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32CopyNull& parent) {
    return i32(const_cast<fasttest::U32CopyNull&>(parent).length);
}

// --- fasttest.U32CopyNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32CopyNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32CopyNull&>(row).length));
}

// --- fasttest.U32CopyNull..Init
// Set all fields to initial values.
inline void fasttest::U32CopyNull_Init(fasttest::U32CopyNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(54);
    parent.pmask = u32(0);
    parent.Value54 = u32(0);
}
inline fasttest::U32CopyOpt::U32CopyOpt() {
    fasttest::U32CopyOpt_Init(*this);
}


// --- fasttest.U32CopyOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32CopyOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32CopyOpt.
// If not successful, quietly return NULL.
inline fasttest::U32CopyOpt* fasttest::U32CopyOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (53);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32CopyOpt);
    return cond ? reinterpret_cast<fasttest::U32CopyOpt*>(&hdr) : NULL;
}

// --- fasttest.U32CopyOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32CopyOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32CopyOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32CopyOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32CopyOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32CopyOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32CopyOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32CopyOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32CopyOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32CopyOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32CopyOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32CopyOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32CopyOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32CopyOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32CopyOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32CopyOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32CopyOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32CopyOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32CopyOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32CopyOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32CopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32CopyOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32CopyOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32CopyOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32CopyOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32CopyOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32CopyOpt& parent, fasttest::U32CopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32CopyOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32CopyOpt& parent, fasttest::U32CopyOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32CopyOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32CopyOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32CopyOpt.Value53.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value53_PresentQ(fasttest::U32CopyOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32CopyOpt.Value53.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value53_SetPresent(fasttest::U32CopyOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32CopyOpt.Value53.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value53_Present_GetBit(fasttest::U32CopyOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32CopyOpt.Value53.Set
inline void fasttest::Value53_Set(fasttest::U32CopyOpt& parent, u32 rhs) {
    parent.Value53 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32CopyOpt.pmask_bitcurs.Reset
inline void fasttest::U32CopyOpt_pmask_bitcurs_Reset(U32CopyOpt_pmask_bitcurs &curs, fasttest::U32CopyOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32CopyOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32CopyOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32CopyOpt_pmask_bitcurs_ValidQ(U32CopyOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32CopyOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32CopyOpt_pmask_bitcurs_Access(U32CopyOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32CopyOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32CopyOpt& parent) {
    return i32(const_cast<fasttest::U32CopyOpt&>(parent).length);
}

// --- fasttest.U32CopyOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32CopyOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32CopyOpt&>(row).length));
}

// --- fasttest.U32CopyOpt..Init
// Set all fields to initial values.
inline void fasttest::U32CopyOpt_Init(fasttest::U32CopyOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(53);
    parent.pmask = u32(0);
    parent.Value53 = u32(53);
}
inline fasttest::U32Delta::U32Delta() {
    fasttest::U32Delta_Init(*this);
}


// --- fasttest.U32Delta.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32Delta by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32Delta.
// If not successful, quietly return NULL.
inline fasttest::U32Delta* fasttest::U32Delta_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (69);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32Delta);
    return cond ? reinterpret_cast<fasttest::U32Delta*>(&hdr) : NULL;
}

// --- fasttest.U32Delta.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32Delta& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32Delta..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32Delta& parent) {
    return i32(const_cast<fasttest::U32Delta&>(parent).length);
}

// --- fasttest.U32Delta..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32Delta& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32Delta&>(row).length));
}

// --- fasttest.U32Delta..Init
// Set all fields to initial values.
inline void fasttest::U32Delta_Init(fasttest::U32Delta& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(69);
    parent.Value69 = u32(69);
}
inline fasttest::U32DeltaImpl::U32DeltaImpl() {
    fasttest::U32DeltaImpl_Init(*this);
}


// --- fasttest.U32DeltaImpl.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32DeltaImpl by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32DeltaImpl.
// If not successful, quietly return NULL.
inline fasttest::U32DeltaImpl* fasttest::U32DeltaImpl_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (70);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32DeltaImpl);
    return cond ? reinterpret_cast<fasttest::U32DeltaImpl*>(&hdr) : NULL;
}

// --- fasttest.U32DeltaImpl.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32DeltaImpl& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32DeltaImpl..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32DeltaImpl& parent) {
    return i32(const_cast<fasttest::U32DeltaImpl&>(parent).length);
}

// --- fasttest.U32DeltaImpl..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32DeltaImpl& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32DeltaImpl&>(row).length));
}

// --- fasttest.U32DeltaImpl..Init
// Set all fields to initial values.
inline void fasttest::U32DeltaImpl_Init(fasttest::U32DeltaImpl& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(70);
    parent.Value70 = u32(0);
}
inline fasttest::U32DeltaNull::U32DeltaNull() {
    fasttest::U32DeltaNull_Init(*this);
}


// --- fasttest.U32DeltaNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32DeltaNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32DeltaNull.
// If not successful, quietly return NULL.
inline fasttest::U32DeltaNull* fasttest::U32DeltaNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (72);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32DeltaNull);
    return cond ? reinterpret_cast<fasttest::U32DeltaNull*>(&hdr) : NULL;
}

// --- fasttest.U32DeltaNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32DeltaNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32DeltaNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32DeltaNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32DeltaNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32DeltaNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32DeltaNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32DeltaNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32DeltaNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32DeltaNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32DeltaNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32DeltaNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32DeltaNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32DeltaNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32DeltaNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32DeltaNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32DeltaNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32DeltaNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32DeltaNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32DeltaNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32DeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32DeltaNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32DeltaNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32DeltaNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32DeltaNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32DeltaNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32DeltaNull& parent, fasttest::U32DeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DeltaNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32DeltaNull& parent, fasttest::U32DeltaNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DeltaNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32DeltaNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32DeltaNull.Value72.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value72_PresentQ(fasttest::U32DeltaNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32DeltaNull.Value72.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value72_SetPresent(fasttest::U32DeltaNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DeltaNull.Value72.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value72_Present_GetBit(fasttest::U32DeltaNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32DeltaNull.Value72.Set
inline void fasttest::Value72_Set(fasttest::U32DeltaNull& parent, u32 rhs) {
    parent.Value72 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DeltaNull.pmask_bitcurs.Reset
inline void fasttest::U32DeltaNull_pmask_bitcurs_Reset(U32DeltaNull_pmask_bitcurs &curs, fasttest::U32DeltaNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32DeltaNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32DeltaNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32DeltaNull_pmask_bitcurs_ValidQ(U32DeltaNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32DeltaNull.pmask_bitcurs.Access
// item access
inline int& fasttest::U32DeltaNull_pmask_bitcurs_Access(U32DeltaNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32DeltaNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32DeltaNull& parent) {
    return i32(const_cast<fasttest::U32DeltaNull&>(parent).length);
}

// --- fasttest.U32DeltaNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32DeltaNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32DeltaNull&>(row).length));
}

// --- fasttest.U32DeltaNull..Init
// Set all fields to initial values.
inline void fasttest::U32DeltaNull_Init(fasttest::U32DeltaNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(72);
    parent.pmask = u32(0);
    parent.Value72 = u32(0);
}
inline fasttest::U32DeltaOpt::U32DeltaOpt() {
    fasttest::U32DeltaOpt_Init(*this);
}


// --- fasttest.U32DeltaOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32DeltaOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32DeltaOpt.
// If not successful, quietly return NULL.
inline fasttest::U32DeltaOpt* fasttest::U32DeltaOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (71);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32DeltaOpt);
    return cond ? reinterpret_cast<fasttest::U32DeltaOpt*>(&hdr) : NULL;
}

// --- fasttest.U32DeltaOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32DeltaOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32DeltaOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32DeltaOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32DeltaOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32DeltaOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32DeltaOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32DeltaOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32DeltaOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32DeltaOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32DeltaOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32DeltaOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32DeltaOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32DeltaOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32DeltaOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32DeltaOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32DeltaOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32DeltaOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32DeltaOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32DeltaOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32DeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32DeltaOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32DeltaOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32DeltaOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32DeltaOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32DeltaOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32DeltaOpt& parent, fasttest::U32DeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DeltaOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32DeltaOpt& parent, fasttest::U32DeltaOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DeltaOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32DeltaOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32DeltaOpt.Value71.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value71_PresentQ(fasttest::U32DeltaOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32DeltaOpt.Value71.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value71_SetPresent(fasttest::U32DeltaOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DeltaOpt.Value71.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value71_Present_GetBit(fasttest::U32DeltaOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32DeltaOpt.Value71.Set
inline void fasttest::Value71_Set(fasttest::U32DeltaOpt& parent, u32 rhs) {
    parent.Value71 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DeltaOpt.pmask_bitcurs.Reset
inline void fasttest::U32DeltaOpt_pmask_bitcurs_Reset(U32DeltaOpt_pmask_bitcurs &curs, fasttest::U32DeltaOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32DeltaOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32DeltaOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32DeltaOpt_pmask_bitcurs_ValidQ(U32DeltaOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32DeltaOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32DeltaOpt_pmask_bitcurs_Access(U32DeltaOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32DeltaOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32DeltaOpt& parent) {
    return i32(const_cast<fasttest::U32DeltaOpt&>(parent).length);
}

// --- fasttest.U32DeltaOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32DeltaOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32DeltaOpt&>(row).length));
}

// --- fasttest.U32DeltaOpt..Init
// Set all fields to initial values.
inline void fasttest::U32DeltaOpt_Init(fasttest::U32DeltaOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(71);
    parent.pmask = u32(0);
    parent.Value71 = u32(71);
}
inline fasttest::U32Dflt::U32Dflt() {
    fasttest::U32Dflt_Init(*this);
}


// --- fasttest.U32Dflt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32Dflt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32Dflt.
// If not successful, quietly return NULL.
inline fasttest::U32Dflt* fasttest::U32Dflt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (36);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32Dflt);
    return cond ? reinterpret_cast<fasttest::U32Dflt*>(&hdr) : NULL;
}

// --- fasttest.U32Dflt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32Dflt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32Dflt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32Dflt& parent) {
    return i32(const_cast<fasttest::U32Dflt&>(parent).length);
}

// --- fasttest.U32Dflt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32Dflt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32Dflt&>(row).length));
}

// --- fasttest.U32Dflt..Init
// Set all fields to initial values.
inline void fasttest::U32Dflt_Init(fasttest::U32Dflt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(36);
    parent.Value = u32(36);
}
inline fasttest::U32DfltNull::U32DfltNull() {
    fasttest::U32DfltNull_Init(*this);
}


// --- fasttest.U32DfltNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32DfltNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32DfltNull.
// If not successful, quietly return NULL.
inline fasttest::U32DfltNull* fasttest::U32DfltNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (38);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32DfltNull);
    return cond ? reinterpret_cast<fasttest::U32DfltNull*>(&hdr) : NULL;
}

// --- fasttest.U32DfltNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32DfltNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32DfltNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32DfltNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32DfltNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32DfltNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32DfltNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32DfltNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32DfltNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32DfltNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32DfltNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32DfltNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32DfltNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32DfltNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32DfltNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32DfltNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32DfltNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32DfltNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32DfltNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32DfltNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32DfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32DfltNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32DfltNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32DfltNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32DfltNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32DfltNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32DfltNull& parent, fasttest::U32DfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DfltNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32DfltNull& parent, fasttest::U32DfltNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DfltNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32DfltNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32DfltNull.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::U32DfltNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32DfltNull.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::U32DfltNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DfltNull.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::U32DfltNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32DfltNull.Value.Set
inline void fasttest::Value_Set(fasttest::U32DfltNull& parent, u32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DfltNull.pmask_bitcurs.Reset
inline void fasttest::U32DfltNull_pmask_bitcurs_Reset(U32DfltNull_pmask_bitcurs &curs, fasttest::U32DfltNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32DfltNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32DfltNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32DfltNull_pmask_bitcurs_ValidQ(U32DfltNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32DfltNull.pmask_bitcurs.Access
// item access
inline int& fasttest::U32DfltNull_pmask_bitcurs_Access(U32DfltNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32DfltNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32DfltNull& parent) {
    return i32(const_cast<fasttest::U32DfltNull&>(parent).length);
}

// --- fasttest.U32DfltNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32DfltNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32DfltNull&>(row).length));
}

// --- fasttest.U32DfltNull..Init
// Set all fields to initial values.
inline void fasttest::U32DfltNull_Init(fasttest::U32DfltNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(38);
    parent.pmask = u32(0);
    parent.Value = u32(0);
}
inline fasttest::U32DfltOpt::U32DfltOpt() {
    fasttest::U32DfltOpt_Init(*this);
}


// --- fasttest.U32DfltOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32DfltOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32DfltOpt.
// If not successful, quietly return NULL.
inline fasttest::U32DfltOpt* fasttest::U32DfltOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (37);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32DfltOpt);
    return cond ? reinterpret_cast<fasttest::U32DfltOpt*>(&hdr) : NULL;
}

// --- fasttest.U32DfltOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32DfltOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32DfltOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32DfltOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32DfltOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32DfltOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32DfltOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32DfltOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32DfltOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32DfltOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32DfltOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32DfltOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32DfltOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32DfltOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32DfltOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32DfltOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32DfltOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32DfltOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32DfltOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32DfltOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32DfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32DfltOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32DfltOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32DfltOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32DfltOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32DfltOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32DfltOpt& parent, fasttest::U32DfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DfltOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32DfltOpt& parent, fasttest::U32DfltOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32DfltOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32DfltOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32DfltOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::U32DfltOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32DfltOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::U32DfltOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DfltOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::U32DfltOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32DfltOpt.Value.Set
inline void fasttest::Value_Set(fasttest::U32DfltOpt& parent, u32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32DfltOpt.pmask_bitcurs.Reset
inline void fasttest::U32DfltOpt_pmask_bitcurs_Reset(U32DfltOpt_pmask_bitcurs &curs, fasttest::U32DfltOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32DfltOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32DfltOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32DfltOpt_pmask_bitcurs_ValidQ(U32DfltOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32DfltOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32DfltOpt_pmask_bitcurs_Access(U32DfltOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32DfltOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32DfltOpt& parent) {
    return i32(const_cast<fasttest::U32DfltOpt&>(parent).length);
}

// --- fasttest.U32DfltOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32DfltOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32DfltOpt&>(row).length));
}

// --- fasttest.U32DfltOpt..Init
// Set all fields to initial values.
inline void fasttest::U32DfltOpt_Init(fasttest::U32DfltOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(37);
    parent.pmask = u32(0);
    parent.Value = u32(37);
}
inline fasttest::U32Incr::U32Incr() {
    fasttest::U32Incr_Init(*this);
}


// --- fasttest.U32Incr.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32Incr by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32Incr.
// If not successful, quietly return NULL.
inline fasttest::U32Incr* fasttest::U32Incr_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (101);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32Incr);
    return cond ? reinterpret_cast<fasttest::U32Incr*>(&hdr) : NULL;
}

// --- fasttest.U32Incr.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32Incr& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32Incr..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32Incr& parent) {
    return i32(const_cast<fasttest::U32Incr&>(parent).length);
}

// --- fasttest.U32Incr..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32Incr& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32Incr&>(row).length));
}

// --- fasttest.U32Incr..Init
// Set all fields to initial values.
inline void fasttest::U32Incr_Init(fasttest::U32Incr& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(101);
    parent.Value101 = u32(101);
}
inline fasttest::U32IncrNV::U32IncrNV() {
    fasttest::U32IncrNV_Init(*this);
}


// --- fasttest.U32IncrNV.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32IncrNV by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32IncrNV.
// If not successful, quietly return NULL.
inline fasttest::U32IncrNV* fasttest::U32IncrNV_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (102);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32IncrNV);
    return cond ? reinterpret_cast<fasttest::U32IncrNV*>(&hdr) : NULL;
}

// --- fasttest.U32IncrNV.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32IncrNV& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32IncrNV..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32IncrNV& parent) {
    return i32(const_cast<fasttest::U32IncrNV&>(parent).length);
}

// --- fasttest.U32IncrNV..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32IncrNV& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32IncrNV&>(row).length));
}

// --- fasttest.U32IncrNV..Init
// Set all fields to initial values.
inline void fasttest::U32IncrNV_Init(fasttest::U32IncrNV& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(102);
    parent.Value102 = u32(0);
}
inline fasttest::U32IncrNull::U32IncrNull() {
    fasttest::U32IncrNull_Init(*this);
}


// --- fasttest.U32IncrNull.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32IncrNull by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32IncrNull.
// If not successful, quietly return NULL.
inline fasttest::U32IncrNull* fasttest::U32IncrNull_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (104);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32IncrNull);
    return cond ? reinterpret_cast<fasttest::U32IncrNull*>(&hdr) : NULL;
}

// --- fasttest.U32IncrNull.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32IncrNull& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32IncrNull.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32IncrNull& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32IncrNull.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32IncrNull& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32IncrNull.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32IncrNull& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32IncrNull.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32IncrNull.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32IncrNull.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32IncrNull& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32IncrNull.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32IncrNull& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32IncrNull.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32IncrNull.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32IncrNull.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32IncrNull.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32IncrNull& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32IncrNull.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32IncrNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32IncrNull.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32IncrNull& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32IncrNull.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32IncrNull& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32IncrNull.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32IncrNull& parent, fasttest::U32IncrNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32IncrNull.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32IncrNull& parent, fasttest::U32IncrNull &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32IncrNull.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32IncrNull& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32IncrNull.Value104.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value104_PresentQ(fasttest::U32IncrNull& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32IncrNull.Value104.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value104_SetPresent(fasttest::U32IncrNull& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32IncrNull.Value104.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value104_Present_GetBit(fasttest::U32IncrNull& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32IncrNull.Value104.Set
inline void fasttest::Value104_Set(fasttest::U32IncrNull& parent, u32 rhs) {
    parent.Value104 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32IncrNull.pmask_bitcurs.Reset
inline void fasttest::U32IncrNull_pmask_bitcurs_Reset(U32IncrNull_pmask_bitcurs &curs, fasttest::U32IncrNull &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32IncrNull_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32IncrNull.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32IncrNull_pmask_bitcurs_ValidQ(U32IncrNull_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32IncrNull.pmask_bitcurs.Access
// item access
inline int& fasttest::U32IncrNull_pmask_bitcurs_Access(U32IncrNull_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32IncrNull..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32IncrNull& parent) {
    return i32(const_cast<fasttest::U32IncrNull&>(parent).length);
}

// --- fasttest.U32IncrNull..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32IncrNull& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32IncrNull&>(row).length));
}

// --- fasttest.U32IncrNull..Init
// Set all fields to initial values.
inline void fasttest::U32IncrNull_Init(fasttest::U32IncrNull& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(104);
    parent.pmask = u32(0);
    parent.Value104 = u32(0);
}
inline fasttest::U32IncrOpt::U32IncrOpt() {
    fasttest::U32IncrOpt_Init(*this);
}


// --- fasttest.U32IncrOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32IncrOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32IncrOpt.
// If not successful, quietly return NULL.
inline fasttest::U32IncrOpt* fasttest::U32IncrOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (103);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32IncrOpt);
    return cond ? reinterpret_cast<fasttest::U32IncrOpt*>(&hdr) : NULL;
}

// --- fasttest.U32IncrOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32IncrOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32IncrOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32IncrOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32IncrOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32IncrOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32IncrOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32IncrOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32IncrOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32IncrOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32IncrOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32IncrOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32IncrOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32IncrOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32IncrOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32IncrOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32IncrOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32IncrOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32IncrOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32IncrOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32IncrOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32IncrOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32IncrOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32IncrOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32IncrOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32IncrOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32IncrOpt& parent, fasttest::U32IncrOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32IncrOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32IncrOpt& parent, fasttest::U32IncrOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32IncrOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32IncrOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32IncrOpt.Value103.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value103_PresentQ(fasttest::U32IncrOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32IncrOpt.Value103.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value103_SetPresent(fasttest::U32IncrOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32IncrOpt.Value103.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value103_Present_GetBit(fasttest::U32IncrOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32IncrOpt.Value103.Set
inline void fasttest::Value103_Set(fasttest::U32IncrOpt& parent, u32 rhs) {
    parent.Value103 = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32IncrOpt.pmask_bitcurs.Reset
inline void fasttest::U32IncrOpt_pmask_bitcurs_Reset(U32IncrOpt_pmask_bitcurs &curs, fasttest::U32IncrOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32IncrOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32IncrOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32IncrOpt_pmask_bitcurs_ValidQ(U32IncrOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32IncrOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32IncrOpt_pmask_bitcurs_Access(U32IncrOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32IncrOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32IncrOpt& parent) {
    return i32(const_cast<fasttest::U32IncrOpt&>(parent).length);
}

// --- fasttest.U32IncrOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32IncrOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32IncrOpt&>(row).length));
}

// --- fasttest.U32IncrOpt..Init
// Set all fields to initial values.
inline void fasttest::U32IncrOpt_Init(fasttest::U32IncrOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(103);
    parent.pmask = u32(0);
    parent.Value103 = u32(103);
}
inline fasttest::U32None::U32None() {
    fasttest::U32None_Init(*this);
}


// --- fasttest.U32None.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32None by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32None.
// If not successful, quietly return NULL.
inline fasttest::U32None* fasttest::U32None_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (3);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32None);
    return cond ? reinterpret_cast<fasttest::U32None*>(&hdr) : NULL;
}

// --- fasttest.U32None.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32None& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32None..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32None& parent) {
    return i32(const_cast<fasttest::U32None&>(parent).length);
}

// --- fasttest.U32None..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32None& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32None&>(row).length));
}

// --- fasttest.U32None..Init
// Set all fields to initial values.
inline void fasttest::U32None_Init(fasttest::U32None& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(3);
    parent.Value = u32(0);
}
inline fasttest::U32NoneOpt::U32NoneOpt() {
    fasttest::U32NoneOpt_Init(*this);
}


// --- fasttest.U32NoneOpt.base.Castdown
// Check if fasttest::TemplateHeader is an instance of U32NoneOpt by checking the type field
// If it is, return the pointer of target type.
// Additionally, check if the length field permits valid instance of U32NoneOpt.
// If not successful, quietly return NULL.
inline fasttest::U32NoneOpt* fasttest::U32NoneOpt_Castdown(fasttest::TemplateHeader &hdr) {
    bool cond = hdr.id == (4);
    cond &= i32(hdr.length) >= ssizeof(fasttest::U32NoneOpt);
    return cond ? reinterpret_cast<fasttest::U32NoneOpt*>(&hdr) : NULL;
}

// --- fasttest.U32NoneOpt.base.Castbase
inline fasttest::TemplateHeader& fasttest::Castbase(fasttest::U32NoneOpt& parent) {
    return reinterpret_cast<fasttest::TemplateHeader&>(parent);
}

// --- fasttest.U32NoneOpt.pmask.N
// Return constant 1
inline int fasttest::pmask_N(fasttest::U32NoneOpt& parent) {
    (void)parent;
    return 1;
}

// --- fasttest.U32NoneOpt.pmask.qFind
// Access value
inline u32& fasttest::pmask_qFind(fasttest::U32NoneOpt& parent, int) {
    return parent.pmask;
}

// --- fasttest.U32NoneOpt.pmask.NBits
// Get max # of bits in the bitset
// Return max. number of bits supported by array
inline int fasttest::pmask_Nbits(fasttest::U32NoneOpt& parent) {
    return pmask_N(parent) * 32;
}

// --- fasttest.U32NoneOpt.pmask.qGetBit
// Retrieve value of bit #BIT_IDX in bit set. No bounds checking
inline bool fasttest::pmask_qGetBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
    return bool((elem >> shift) & 1); // extract bit
}

// --- fasttest.U32NoneOpt.pmask.GetBit
// Retrieve value of bit #BIT_IDX in bit set. If bit index is out of bounds, return 0.
inline bool fasttest::pmask_GetBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    bool ret = false;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch element
        ret = (elem >> shift) & 1;                 // extract bit
    }
    return ret;
}

// --- fasttest.U32NoneOpt.pmask.BitsEmptyQ
// Check if all the bits in the bitset are equal to zero
inline bool fasttest::pmask_BitsEmptyQ(fasttest::U32NoneOpt& parent) {
    bool retval = true;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        if (pmask_qFind(parent,i) != 0) {
            retval = false;
            break;
        }
    }
    return retval;
}

// --- fasttest.U32NoneOpt.pmask.Sum1s
inline u64 fasttest::pmask_Sum1s(fasttest::U32NoneOpt& parent) {
    u64 sum = 0;
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        sum += algo::u32_Count1s(pmask_qFind(parent, i));
    }
    return sum;
}

// --- fasttest.U32NoneOpt.pmask.qClearBit
// Clear bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qClearBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem & ~(u32(1) << shift); // clear bit
}

// --- fasttest.U32NoneOpt.pmask.ClearBit
// Clear bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing
inline void fasttest::pmask_ClearBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem & ~(u32(1) << shift); // clear bit
    }
}

// --- fasttest.U32NoneOpt.pmask.qSetBit
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(1) << shift); // set bit
}

// --- fasttest.U32NoneOpt.pmask.SetBit
// Set bit # BIT_IDX in bit set. If bit index is out of bounds, do nothing.
inline void fasttest::pmask_SetBit(fasttest::U32NoneOpt& parent, u32 bit_idx) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u64 lim = pmask_N(parent);
    if (elem_idx < lim) {
        u32 &elem = pmask_qFind(parent, elem_idx); // fetch
        elem = elem | (u32(1) << shift); // set bit
    }
}

// --- fasttest.U32NoneOpt.pmask.qSetBitVal
// Set bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qSetBitVal(fasttest::U32NoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = (elem & ~(u32(1) << shift)) | (u32(val) << shift); // insert new value
}

// --- fasttest.U32NoneOpt.pmask.qOrBitVal
// Or bit # BIT_IDX in bit set. No bounds checking
inline void fasttest::pmask_qOrBitVal(fasttest::U32NoneOpt& parent, u32 bit_idx, bool val) {
    u64 elem_idx = bit_idx >> 5;
    u64 shift = bit_idx & 31;
    u32 &elem = pmask_qFind(parent, elem_idx); // fetch
    elem = elem | (u32(val) << shift); // Or in val into elem
}

// --- fasttest.U32NoneOpt.pmask.ClearBitsAll
// Set all bits of array to zero.
// Note: this does not change what NBits will return.
inline void fasttest::pmask_ClearBitsAll(fasttest::U32NoneOpt& parent) {
    u64 n = pmask_N(parent);
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) = 0;
    }
}

// --- fasttest.U32NoneOpt.pmask.ClearBits
// Zero in PARENT any bits that are set in RHS.
inline void fasttest::pmask_ClearBits(fasttest::U32NoneOpt& parent, fasttest::U32NoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) &= ~pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32NoneOpt.pmask.OrBits
// Set PARENT to union of two bitsets.
// (This function is not named Set.. to avoid triple entendre).
inline void fasttest::pmask_OrBits(fasttest::U32NoneOpt& parent, fasttest::U32NoneOpt &rhs) {
    u64 n = u64_Min(pmask_N(parent), pmask_N(rhs));
    for (u64 i = 0; i < n; i++) {
        pmask_qFind(parent, i) |= pmask_qFind(rhs, i);
    }
}

// --- fasttest.U32NoneOpt.pmask.Sup
// Return smallest number N such that indexes of all 1 bits are below N
inline i32 fasttest::pmask_Sup(fasttest::U32NoneOpt& parent) {
    u64 lim = pmask_N(parent);
    i32 ret = 0;
    for (int i = lim-1; i >= 0; i--) {
        u32 &val = pmask_qFind(parent, i);
        if (val) {
            u32 bitidx = algo::u64_BitScanReverse(val) + 1;
            ret = i * 32 + bitidx;
            break;
        }
    }
    return ret;
}

// --- fasttest.U32NoneOpt.Value.PresentQ
// Return true if the field is marked in the presence mask
inline bool fasttest::Value_PresentQ(fasttest::U32NoneOpt& parent) {
    return pmask_qGetBit(parent, 0);
}

// --- fasttest.U32NoneOpt.Value.SetPresent
// Set presence bit for this field in the pmask
inline void fasttest::Value_SetPresent(fasttest::U32NoneOpt& parent) {
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32NoneOpt.Value.Present_GetBit
// Return field's bit number in the pmask
inline int fasttest::Value_Present_GetBit(fasttest::U32NoneOpt& parent) {
    int retval = 0;
    (void)parent;//only to avoid -Wunused-parameter
    return retval;
}

// --- fasttest.U32NoneOpt.Value.Set
inline void fasttest::Value_Set(fasttest::U32NoneOpt& parent, u32 rhs) {
    parent.Value = rhs;
    pmask_qSetBit(parent, 0); // mark presence in pmask
}

// --- fasttest.U32NoneOpt.pmask_bitcurs.Reset
inline void fasttest::U32NoneOpt_pmask_bitcurs_Reset(U32NoneOpt_pmask_bitcurs &curs, fasttest::U32NoneOpt &parent) {
    curs.elems = &pmask_qFind(parent,0);
    curs.n_elems = pmask_N(parent);
    curs.bit = -1;
    U32NoneOpt_pmask_bitcurs_Next(curs);
}

// --- fasttest.U32NoneOpt.pmask_bitcurs.ValidQ
// cursor points to valid item
inline bool fasttest::U32NoneOpt_pmask_bitcurs_ValidQ(U32NoneOpt_pmask_bitcurs &curs) {
    return curs.bit < curs.n_elems*32;
}

// --- fasttest.U32NoneOpt.pmask_bitcurs.Access
// item access
inline int& fasttest::U32NoneOpt_pmask_bitcurs_Access(U32NoneOpt_pmask_bitcurs &curs) {
    return curs.bit;
}

// --- fasttest.U32NoneOpt..GetMsgLength
// Message length (uses length field)
inline i32 fasttest::GetMsgLength(const fasttest::U32NoneOpt& parent) {
    return i32(const_cast<fasttest::U32NoneOpt&>(parent).length);
}

// --- fasttest.U32NoneOpt..GetMsgMemptr
// Memptr encompassing the message (uses length field)
inline algo::memptr fasttest::GetMsgMemptr(const fasttest::U32NoneOpt& row) {
    return algo::memptr((u8*)&row, i32(const_cast<fasttest::U32NoneOpt&>(row).length));
}

// --- fasttest.U32NoneOpt..Init
// Set all fields to initial values.
inline void fasttest::U32NoneOpt_Init(fasttest::U32NoneOpt& parent) {
    parent.length = u32(ssizeof(parent) + (0));
    parent.id = u32(4);
    parent.pmask = u32(0);
    parent.Value = u32(0);
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVConst &row) {// cfmt:fasttest.BVConst.String
    fasttest::BVConst_Print(const_cast<fasttest::BVConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVConstOpt &row) {// cfmt:fasttest.BVConstOpt.String
    fasttest::BVConstOpt_Print(const_cast<fasttest::BVConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVCopy &row) {// cfmt:fasttest.BVCopy.String
    fasttest::BVCopy_Print(const_cast<fasttest::BVCopy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVCopyNull &row) {// cfmt:fasttest.BVCopyNull.String
    fasttest::BVCopyNull_Print(const_cast<fasttest::BVCopyNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVCopyOpt &row) {// cfmt:fasttest.BVCopyOpt.String
    fasttest::BVCopyOpt_Print(const_cast<fasttest::BVCopyOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVDflt &row) {// cfmt:fasttest.BVDflt.String
    fasttest::BVDflt_Print(const_cast<fasttest::BVDflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVDfltNull &row) {// cfmt:fasttest.BVDfltNull.String
    fasttest::BVDfltNull_Print(const_cast<fasttest::BVDfltNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVDfltOpt &row) {// cfmt:fasttest.BVDfltOpt.String
    fasttest::BVDfltOpt_Print(const_cast<fasttest::BVDfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVNone &row) {// cfmt:fasttest.BVNone.String
    fasttest::BVNone_Print(const_cast<fasttest::BVNone&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::BVNoneOpt &row) {// cfmt:fasttest.BVNoneOpt.String
    fasttest::BVNoneOpt_Print(const_cast<fasttest::BVNoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleEnum &row) {// cfmt:fasttest.SampleEnum.String
    fasttest::SampleEnum_Print(const_cast<fasttest::SampleEnum&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleSet &row) {// cfmt:fasttest.SampleSet.String
    fasttest::SampleSet_Print(const_cast<fasttest::SampleSet&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::FieldId &row) {// cfmt:fasttest.FieldId.String
    fasttest::FieldId_Print(const_cast<fasttest::FieldId&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::FirstSeq &row) {// cfmt:fasttest.FirstSeq.String
    fasttest::FirstSeq_Print(const_cast<fasttest::FirstSeq&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::OptSgmGrp &row) {// cfmt:fasttest.OptSgmGrp.String
    fasttest::OptSgmGrp_Print(const_cast<fasttest::OptSgmGrp&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::GroupSgmOpt &row) {// cfmt:fasttest.GroupSgmOpt.String
    fasttest::GroupSgmOpt_Print(const_cast<fasttest::GroupSgmOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvGrp &row) {// cfmt:fasttest.TrvGrp.String
    fasttest::TrvGrp_Print(const_cast<fasttest::TrvGrp&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::GroupTrv &row) {// cfmt:fasttest.GroupTrv.String
    fasttest::GroupTrv_Print(const_cast<fasttest::GroupTrv&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::OptTrvGrp &row) {// cfmt:fasttest.OptTrvGrp.String
    fasttest::OptTrvGrp_Print(const_cast<fasttest::OptTrvGrp&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::GroupTrvOpt &row) {// cfmt:fasttest.GroupTrvOpt.String
    fasttest::GroupTrvOpt_Print(const_cast<fasttest::GroupTrvOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32Const &row) {// cfmt:fasttest.I32Const.String
    fasttest::I32Const_Print(const_cast<fasttest::I32Const&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32ConstOpt &row) {// cfmt:fasttest.I32ConstOpt.String
    fasttest::I32ConstOpt_Print(const_cast<fasttest::I32ConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32Copy &row) {// cfmt:fasttest.I32Copy.String
    fasttest::I32Copy_Print(const_cast<fasttest::I32Copy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32CopyNull &row) {// cfmt:fasttest.I32CopyNull.String
    fasttest::I32CopyNull_Print(const_cast<fasttest::I32CopyNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32CopyOpt &row) {// cfmt:fasttest.I32CopyOpt.String
    fasttest::I32CopyOpt_Print(const_cast<fasttest::I32CopyOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32Delta &row) {// cfmt:fasttest.I32Delta.String
    fasttest::I32Delta_Print(const_cast<fasttest::I32Delta&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32DeltaImpl &row) {// cfmt:fasttest.I32DeltaImpl.String
    fasttest::I32DeltaImpl_Print(const_cast<fasttest::I32DeltaImpl&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32DeltaNull &row) {// cfmt:fasttest.I32DeltaNull.String
    fasttest::I32DeltaNull_Print(const_cast<fasttest::I32DeltaNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32DeltaOpt &row) {// cfmt:fasttest.I32DeltaOpt.String
    fasttest::I32DeltaOpt_Print(const_cast<fasttest::I32DeltaOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32Dflt &row) {// cfmt:fasttest.I32Dflt.String
    fasttest::I32Dflt_Print(const_cast<fasttest::I32Dflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32DfltNull &row) {// cfmt:fasttest.I32DfltNull.String
    fasttest::I32DfltNull_Print(const_cast<fasttest::I32DfltNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32DfltOpt &row) {// cfmt:fasttest.I32DfltOpt.String
    fasttest::I32DfltOpt_Print(const_cast<fasttest::I32DfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32Incr &row) {// cfmt:fasttest.I32Incr.String
    fasttest::I32Incr_Print(const_cast<fasttest::I32Incr&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32IncrNV &row) {// cfmt:fasttest.I32IncrNV.String
    fasttest::I32IncrNV_Print(const_cast<fasttest::I32IncrNV&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32IncrNull &row) {// cfmt:fasttest.I32IncrNull.String
    fasttest::I32IncrNull_Print(const_cast<fasttest::I32IncrNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32IncrOpt &row) {// cfmt:fasttest.I32IncrOpt.String
    fasttest::I32IncrOpt_Print(const_cast<fasttest::I32IncrOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32None &row) {// cfmt:fasttest.I32None.String
    fasttest::I32None_Print(const_cast<fasttest::I32None&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::I32NoneOpt &row) {// cfmt:fasttest.I32NoneOpt.String
    fasttest::I32NoneOpt_Print(const_cast<fasttest::I32NoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::MsgPmap &row) {// cfmt:fasttest.MsgPmap.String
    fasttest::MsgPmap_Print(const_cast<fasttest::MsgPmap&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::OptSgmSeq &row) {// cfmt:fasttest.OptSgmSeq.String
    fasttest::OptSgmSeq_Print(const_cast<fasttest::OptSgmSeq&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::OptTrvSeq &row) {// cfmt:fasttest.OptTrvSeq.String
    fasttest::OptTrvSeq_Print(const_cast<fasttest::OptTrvSeq&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::Reset &row) {// cfmt:fasttest.Reset.String
    fasttest::Reset_Print(const_cast<fasttest::Reset&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleEnumConst &row) {// cfmt:fasttest.SampleEnumConst.String
    fasttest::SampleEnumConst_Print(const_cast<fasttest::SampleEnumConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleEnumCopy &row) {// cfmt:fasttest.SampleEnumCopy.String
    fasttest::SampleEnumCopy_Print(const_cast<fasttest::SampleEnumCopy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleEnumDefault &row) {// cfmt:fasttest.SampleEnumDefault.String
    fasttest::SampleEnumDefault_Print(const_cast<fasttest::SampleEnumDefault&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleSetConst &row) {// cfmt:fasttest.SampleSetConst.String
    fasttest::SampleSetConst_Print(const_cast<fasttest::SampleSetConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleSetCopy &row) {// cfmt:fasttest.SampleSetCopy.String
    fasttest::SampleSetCopy_Print(const_cast<fasttest::SampleSetCopy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SampleSetDefault &row) {// cfmt:fasttest.SampleSetDefault.String
    fasttest::SampleSetDefault_Print(const_cast<fasttest::SampleSetDefault&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclConst &row) {// cfmt:fasttest.SclConst.String
    fasttest::SclConst_Print(const_cast<fasttest::SclConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclConstOpt &row) {// cfmt:fasttest.SclConstOpt.String
    fasttest::SclConstOpt_Print(const_cast<fasttest::SclConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclCopy &row) {// cfmt:fasttest.SclCopy.String
    fasttest::SclCopy_Print(const_cast<fasttest::SclCopy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclCopyNull &row) {// cfmt:fasttest.SclCopyNull.String
    fasttest::SclCopyNull_Print(const_cast<fasttest::SclCopyNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclCopyOpt &row) {// cfmt:fasttest.SclCopyOpt.String
    fasttest::SclCopyOpt_Print(const_cast<fasttest::SclCopyOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDelta &row) {// cfmt:fasttest.SclDelta.String
    fasttest::SclDelta_Print(const_cast<fasttest::SclDelta&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDeltaImpl &row) {// cfmt:fasttest.SclDeltaImpl.String
    fasttest::SclDeltaImpl_Print(const_cast<fasttest::SclDeltaImpl&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDeltaNull &row) {// cfmt:fasttest.SclDeltaNull.String
    fasttest::SclDeltaNull_Print(const_cast<fasttest::SclDeltaNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDeltaOpt &row) {// cfmt:fasttest.SclDeltaOpt.String
    fasttest::SclDeltaOpt_Print(const_cast<fasttest::SclDeltaOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDflt &row) {// cfmt:fasttest.SclDflt.String
    fasttest::SclDflt_Print(const_cast<fasttest::SclDflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDfltNull &row) {// cfmt:fasttest.SclDfltNull.String
    fasttest::SclDfltNull_Print(const_cast<fasttest::SclDfltNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclDfltOpt &row) {// cfmt:fasttest.SclDfltOpt.String
    fasttest::SclDfltOpt_Print(const_cast<fasttest::SclDfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclNone &row) {// cfmt:fasttest.SclNone.String
    fasttest::SclNone_Print(const_cast<fasttest::SclNone&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SclNoneOpt &row) {// cfmt:fasttest.SclNoneOpt.String
    fasttest::SclNoneOpt_Print(const_cast<fasttest::SclNoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SecondSeq &row) {// cfmt:fasttest.SecondSeq.String
    fasttest::SecondSeq_Print(const_cast<fasttest::SecondSeq&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqOrder &row) {// cfmt:fasttest.SeqOrder.String
    fasttest::SeqOrder_Print(const_cast<fasttest::SeqOrder&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqSgmOpt &row) {// cfmt:fasttest.SeqSgmOpt.String
    fasttest::SeqSgmOpt_Print(const_cast<fasttest::SeqSgmOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeq &row) {// cfmt:fasttest.TrvSeq.String
    fasttest::TrvSeq_Print(const_cast<fasttest::TrvSeq&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrv &row) {// cfmt:fasttest.SeqTrv.String
    fasttest::SeqTrv_Print(const_cast<fasttest::SeqTrv&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqLenConst &row) {// cfmt:fasttest.TrvSeqLenConst.String
    fasttest::TrvSeqLenConst_Print(const_cast<fasttest::TrvSeqLenConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenConst &row) {// cfmt:fasttest.SeqTrvLenConst.String
    fasttest::SeqTrvLenConst_Print(const_cast<fasttest::SeqTrvLenConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqLenConstOpt &row) {// cfmt:fasttest.TrvSeqLenConstOpt.String
    fasttest::TrvSeqLenConstOpt_Print(const_cast<fasttest::TrvSeqLenConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenConstOpt &row) {// cfmt:fasttest.SeqTrvLenConstOpt.String
    fasttest::SeqTrvLenConstOpt_Print(const_cast<fasttest::SeqTrvLenConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqLenDflt &row) {// cfmt:fasttest.TrvSeqLenDflt.String
    fasttest::TrvSeqLenDflt_Print(const_cast<fasttest::TrvSeqLenDflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenDflt &row) {// cfmt:fasttest.SeqTrvLenDflt.String
    fasttest::SeqTrvLenDflt_Print(const_cast<fasttest::SeqTrvLenDflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqDfltOpt &row) {// cfmt:fasttest.TrvSeqDfltOpt.String
    fasttest::TrvSeqDfltOpt_Print(const_cast<fasttest::TrvSeqDfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenDfltOpt &row) {// cfmt:fasttest.SeqTrvLenDfltOpt.String
    fasttest::SeqTrvLenDfltOpt_Print(const_cast<fasttest::SeqTrvLenDfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqLenNone &row) {// cfmt:fasttest.TrvSeqLenNone.String
    fasttest::TrvSeqLenNone_Print(const_cast<fasttest::TrvSeqLenNone&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenNone &row) {// cfmt:fasttest.SeqTrvLenNone.String
    fasttest::SeqTrvLenNone_Print(const_cast<fasttest::SeqTrvLenNone&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TrvSeqLenNoneOpt &row) {// cfmt:fasttest.TrvSeqLenNoneOpt.String
    fasttest::TrvSeqLenNoneOpt_Print(const_cast<fasttest::TrvSeqLenNoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvLenNoneOpt &row) {// cfmt:fasttest.SeqTrvLenNoneOpt.String
    fasttest::SeqTrvLenNoneOpt_Print(const_cast<fasttest::SeqTrvLenNoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::SeqTrvOpt &row) {// cfmt:fasttest.SeqTrvOpt.String
    fasttest::SeqTrvOpt_Print(const_cast<fasttest::SeqTrvOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrConst &row) {// cfmt:fasttest.StrConst.String
    fasttest::StrConst_Print(const_cast<fasttest::StrConst&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrConstOpt &row) {// cfmt:fasttest.StrConstOpt.String
    fasttest::StrConstOpt_Print(const_cast<fasttest::StrConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrCopy &row) {// cfmt:fasttest.StrCopy.String
    fasttest::StrCopy_Print(const_cast<fasttest::StrCopy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrCopyNull &row) {// cfmt:fasttest.StrCopyNull.String
    fasttest::StrCopyNull_Print(const_cast<fasttest::StrCopyNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrCopyOpt &row) {// cfmt:fasttest.StrCopyOpt.String
    fasttest::StrCopyOpt_Print(const_cast<fasttest::StrCopyOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrDflt &row) {// cfmt:fasttest.StrDflt.String
    fasttest::StrDflt_Print(const_cast<fasttest::StrDflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrDfltNull &row) {// cfmt:fasttest.StrDfltNull.String
    fasttest::StrDfltNull_Print(const_cast<fasttest::StrDfltNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrDfltOpt &row) {// cfmt:fasttest.StrDfltOpt.String
    fasttest::StrDfltOpt_Print(const_cast<fasttest::StrDfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrNone &row) {// cfmt:fasttest.StrNone.String
    fasttest::StrNone_Print(const_cast<fasttest::StrNone&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::StrNoneOpt &row) {// cfmt:fasttest.StrNoneOpt.String
    fasttest::StrNoneOpt_Print(const_cast<fasttest::StrNoneOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::TemplateHeader &row) {// cfmt:fasttest.TemplateHeader.String
    fasttest::TemplateHeader_Print(const_cast<fasttest::TemplateHeader&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32Const &row) {// cfmt:fasttest.U32Const.String
    fasttest::U32Const_Print(const_cast<fasttest::U32Const&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32ConstOpt &row) {// cfmt:fasttest.U32ConstOpt.String
    fasttest::U32ConstOpt_Print(const_cast<fasttest::U32ConstOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32Copy &row) {// cfmt:fasttest.U32Copy.String
    fasttest::U32Copy_Print(const_cast<fasttest::U32Copy&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32CopyNull &row) {// cfmt:fasttest.U32CopyNull.String
    fasttest::U32CopyNull_Print(const_cast<fasttest::U32CopyNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32CopyOpt &row) {// cfmt:fasttest.U32CopyOpt.String
    fasttest::U32CopyOpt_Print(const_cast<fasttest::U32CopyOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32Delta &row) {// cfmt:fasttest.U32Delta.String
    fasttest::U32Delta_Print(const_cast<fasttest::U32Delta&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32DeltaImpl &row) {// cfmt:fasttest.U32DeltaImpl.String
    fasttest::U32DeltaImpl_Print(const_cast<fasttest::U32DeltaImpl&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32DeltaNull &row) {// cfmt:fasttest.U32DeltaNull.String
    fasttest::U32DeltaNull_Print(const_cast<fasttest::U32DeltaNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32DeltaOpt &row) {// cfmt:fasttest.U32DeltaOpt.String
    fasttest::U32DeltaOpt_Print(const_cast<fasttest::U32DeltaOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32Dflt &row) {// cfmt:fasttest.U32Dflt.String
    fasttest::U32Dflt_Print(const_cast<fasttest::U32Dflt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32DfltNull &row) {// cfmt:fasttest.U32DfltNull.String
    fasttest::U32DfltNull_Print(const_cast<fasttest::U32DfltNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32DfltOpt &row) {// cfmt:fasttest.U32DfltOpt.String
    fasttest::U32DfltOpt_Print(const_cast<fasttest::U32DfltOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32Incr &row) {// cfmt:fasttest.U32Incr.String
    fasttest::U32Incr_Print(const_cast<fasttest::U32Incr&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32IncrNV &row) {// cfmt:fasttest.U32IncrNV.String
    fasttest::U32IncrNV_Print(const_cast<fasttest::U32IncrNV&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32IncrNull &row) {// cfmt:fasttest.U32IncrNull.String
    fasttest::U32IncrNull_Print(const_cast<fasttest::U32IncrNull&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32IncrOpt &row) {// cfmt:fasttest.U32IncrOpt.String
    fasttest::U32IncrOpt_Print(const_cast<fasttest::U32IncrOpt&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32None &row) {// cfmt:fasttest.U32None.String
    fasttest::U32None_Print(const_cast<fasttest::U32None&>(row), str);
    return str;
}

inline algo::cstring &algo::operator <<(algo::cstring &str, const fasttest::U32NoneOpt &row) {// cfmt:fasttest.U32NoneOpt.String
    fasttest::U32NoneOpt_Print(const_cast<fasttest::U32NoneOpt&>(row), str);
    return str;
}